synthesisui 0.16.365 → 0.16.367

package/dist/color-forms.js

@@ -130,6 +130,98 @@ function fromHsl(raw) {
         alpha: Number.isFinite(alpha) ? Math.max(0, Math.min(1, alpha)) : 1,
     };
 }
+/**
+ * `oklch(69.6% 0.17 162.48)` - E ELE ERA 42% DOS LITERAIS DE COR DE UM SISTEMA REAL.
+ *
+ * O QUE O CLIENTE GANHA: a cor que o Tailwind 4 escreve por padrão passa a ser interpretada como
+ * cor. Antes ela chegava na receita (o coletor a lê) e morria aqui - `colorForm` devolvia `null` -,
+ * então `deltaE` não a comparava, `namedByValue` não a indexava, o v2 nunca propunha agrupá-la nem
+ * nomeá-la, e nada a declarava como lacuna. Ela era invisível nos dois sentidos.
+ *
+ * MEDIDO em 03/09, nos `looks` de duas populações: 94 usos no `codelevel-ui` e 23 no
+ * `frontend-hub`, 39 valores distintos - e ZERO deles no `observed` das três populações, que é a
+ * régua de valores. É a decisão 1 do dono (21/08): *"toda forma de cor entra - hex, rgb, rgba, hsl,
+ * color-mix, oklch"*.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * O GAMUT É MAPEADO POR CHROMA, E NÃO CLAMPADO - e essa é a decisão que impede a cor errada
+ *
+ * OKLCh descreve cores que o sRGB não alcança: 25 dos 39 valores medidos caem fora. A saída barata
+ * é clampar cada canal em 0-255; a certa é a do CSS Color 4, reduzir o CHROMA mantendo o L e o H até
+ * a cor caber. As duas DISCORDAM em 22 dos 25:
+ *
+ *     oklch(69.6% 0.17 162.48)    clamp #00bc7d    chroma-map #00b981
+ *     oklch(76.9% 0.188 70.08)    clamp #fe9a00    chroma-map #f69e00
+ *
+ * `#00b981` é o emerald que o navegador pinta; `#00bc7d` é uma cor que ninguém vê. Um hex errado
+ * aqui não fica quieto: ele vira a chave que decide se duas cores são a mesma e se um token dele
+ * casa com um valor - as duas afirmações que este produto não pode errar. O laço binário custa 24
+ * iterações e só roda para quem está fora.
+ */
+function fromOklch(raw) {
+    const m = /^oklch\(([^)]*)\)$/i.exec(raw.trim());
+    if (!m)
+        return null;
+    const [body, alphaPart] = m[1].split("/");
+    const parts = body
+        .trim()
+        .split(/[\s,]+/)
+        .filter(Boolean);
+    if (parts.length < 3)
+        return null;
+    /** L aceita 0-1 e 0%-100%; C aceita o número e o percentual, cujo 100% é 0.4 por spec. */
+    const L = unit(parts[0]);
+    const C = parts[1].trim().endsWith("%")
+        ? unit(parts[1], 0.4)
+        : Number.parseFloat(parts[1]);
+    /** `none` é um ângulo ausente, e ausente é zero - com C=0 o matiz não muda nada de qualquer forma. */
+    const H = /^none$/i.test(parts[2].trim()) ? 0 : Number.parseFloat(parts[2]);
+    if (![L, C, H].every(Number.isFinite))
+        return null;
+    const linear = (chroma) => {
+        const h = (H * Math.PI) / 180;
+        const a = chroma * Math.cos(h);
+        const b = chroma * Math.sin(h);
+        const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+        const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+        const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+        const l3 = l_ ** 3;
+        const m3 = m_ ** 3;
+        const s3 = s_ ** 3;
+        return [
+            4.0767416621 * l3 - 3.3077115913 * m3 + 0.2309699292 * s3,
+            -1.2684380046 * l3 + 2.6097574011 * m3 - 0.3413193965 * s3,
+            -0.0041960863 * l3 - 0.7034186147 * m3 + 1.707614701 * s3,
+        ];
+    };
+    /** A folga de 1e-4 é ruído de ponto flutuante, não cor fora do gamut. */
+    const fits = (c) => c.every((x) => x >= -0.0001 && x <= 1.0001);
+    let channels = linear(Math.max(0, C));
+    if (!fits(channels)) {
+        let lo = 0;
+        let hi = Math.max(0, C);
+        for (let i = 0; i < 24; i++) {
+            const mid = (lo + hi) / 2;
+            if (fits(linear(mid)))
+                lo = mid;
+            else
+                hi = mid;
+        }
+        channels = linear(lo);
+    }
+    /** sRGB transfer function - o mesmo expoente que o navegador usa. */
+    const gamma = (x) => {
+        const v = Math.max(0, Math.min(1, x));
+        return (v <= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055) * 255;
+    };
+    const [r, g, b] = channels.map(gamma);
+    const rawAlpha = alphaPart ?? parts[3];
+    const alpha = rawAlpha === undefined ? 1 : unit(rawAlpha);
+    return {
+        hex: `#${hex2(r)}${hex2(g)}${hex2(b)}`,
+        alpha: Number.isFinite(alpha) ? Math.max(0, Math.min(1, alpha)) : 1,
+    };
+}
 /**
  * QUALQUER FORMA -> a canônica. `null` para o que não é uma cor literal.
  *
@@ -140,7 +232,7 @@ export function colorForm(value) {
     const v = value.trim();
     if (!v || /^(transparent|currentcolor|inherit|initial|unset|none)$/i.test(v))
         return null;
-    return fromHex(v) ?? fromRgb(v) ?? fromHsl(v);
+    return fromHex(v) ?? fromRgb(v) ?? fromHsl(v) ?? fromOklch(v);
 }
 /**
  * AS CORES LITERAIS DENTRO DE UM VALOR - inclusive as de dentro de uma função de composição.
@@ -163,7 +255,7 @@ export function colorsIn(value) {
         seen.add(key);
         out.push(c);
     };
-    const rest = value.replace(/\b(?:rgba?|hsla?)\([^)]*\)/gi, (m) => (push(colorForm(m)), " "));
+    const rest = value.replace(/\b(?:rgba?|hsla?|oklch)\([^)]*\)/gi, (m) => (push(colorForm(m)), " "));
     for (const m of rest.match(/#[0-9a-f]{3,8}\b/gi) ?? [])
         push(colorForm(m));
     return out;

package/dist/commands/align.js

@@ -114,7 +114,15 @@ opts = {}) {
         out.push({
             says: "The system's tools are declared here and still waiting for your approval - until you give it, I cannot reach the import playbook, only measure your files.",
             run: "/mcp",
-            then: "then say: import my design system",
+            /**
+             * O VALOR NÃO TRAZ O PRÓPRIO RÓTULO - quem rotula é quem desenha.
+             *
+             * Ele dizia `then say: import my design system`, e o render põe "then, to pick up where you
+             * left off:" acima: a tela saía com dois rótulos e dois "then" para UM passo. É o defeito que
+             * o #1314 consertou, reintroduzido por um valor que carregava a moldura dentro.
+             */
+            then: "import my design system",
+            where: "agent",
         });
     const locks = (await locksIn(root)).filter((l) => l.slug && !l.adopted);
     /** Sem sistema instalado não há alinho a cobrar - não é desalinho, é um repo sem DS. */
@@ -535,7 +543,7 @@ from = "session") {
             : from === "shell"
                 ? "This repo is out of alignment with the design system that governs it:"
                 : "Before this session starts, this environment is out of alignment with the design system that governs it:",
-        ...grouped(items),
+        ...grouped(items, from),
     ].join("\n");
 }
 /**
@@ -554,7 +562,13 @@ from = "session") {
  *
  * A ordem é a da primeira aparição: o primeiro achado decide onde o grupo dele fica.
  */
-function grouped(items) {
+function grouped(items, 
+/**
+ * QUEM ESTÁ LENDO decide duas coisas aqui: se um remédio do agente precisa dizer onde mora, e se
+ * a linha ganha cor. Numa sessão a pessoa JÁ está no agente, e o rótulo seria a tela falando de
+ * si mesma.
+ */
+from = "session") {
     const order = [];
     const byRun = new Map();
     for (const m of items) {
@@ -571,12 +585,29 @@ function grouped(items) {
         const group = byRun.get(key) ?? [];
         for (const m of group)
             out.push(`  - ${m.says}`);
-        const { run, then } = group[0];
-        if (run)
-            out.push(`      ${run}`);
+        const { run, then, where } = group[0];
+        /**
+         * A HIERARQUIA, e ela faltava inteira - *"o texto está sem hierarquia de cor, está muito ruim"*
+         * (dono, na 0.16.365). Este bloco saía cru enquanto a ação recomendada, quinze linhas acima,
+         * usava seção, azul e cinza. A paleta é a que já existe e no papel que ela declara: `blue` é o
+         * que está VIVO (o que ele roda ou diz), `dim` é a prosa que emoldura.
+         *
+         * `paint` se apaga sozinho sem TTY, então o `SessionStart` - que entrega texto a um modelo -
+         * continua recebendo o mesmo texto de sempre, sem um único código de escape.
+         */
+        if (run) {
+            /**
+             * UM REMÉDIO DO AGENTE DIZ ONDE MORA, na superfície onde ele não é digitável. `/mcp` no
+             * prompt do zsh é um comando que não existe; com o rótulo, a linha continua colável no lugar
+             * certo em vez de mandar a pessoa ao lugar errado.
+             */
+            if (where === "agent" && from !== "session")
+                out.push(paint.dim(`      ${say("inside your agent session:")}`));
+            out.push(paint.blue(`      ${run}`));
+        }
         /** O `then` sai numa linha própria e rotulada: um segundo comando solto lê como parte do primeiro. */
         if (then)
-            out.push(`      then, to pick up where you left off:\n      ${then}`);
+            out.push(`${paint.dim(`      ${say("then, to pick up where you left off:")}`)}\n${paint.blue(`      ${then}`)}`);
     }
     return out;
 }
@@ -595,13 +626,24 @@ function grouped(items) {
  * própria e sem saber de defasagem nenhuma - duas portas para a mesma sala, e uma delas cega
  * (dono, 07/08).
  */
-export async function misalignments(root, opts = {}) {
+export async function misalignments(root, 
+/**
+ * `home` ATRAVESSA ATÉ AQUI, e a falta dele é por que a regressão da 0.16.365 passou.
+ *
+ * `localMisalignments` sempre aceitou `home` - a sessão e a decisão sobre as ferramentas moram
+ * nele, não no repo - e esta porta, que é a que o `connect` usa, não o repassava. Consequência:
+ * o aviso da aprovação pendente era inalcançável por teste pela jornada real; qualquer cenário
+ * montado aqui lia o `~/.claude.json` da máquina que roda a suíte, e passava por sorte.
+ */
+opts = {}) {
     const items = await localMisalignments(root, {
         ...(opts.cli ? { cli: opts.cli } : {}),
+        ...(opts.home ? { home: opts.home } : {}),
     }).catch(() => []);
     /** A única linha que custa rede, e ela some inteira quando não há rede. */
     const remote = await versionBehind(root, {
         ...(opts.cli ? { cli: opts.cli } : {}),
+        ...(opts.home ? { home: opts.home } : {}),
     }).catch(() => null);
     if (remote)
         items.push(remote);
@@ -626,10 +668,14 @@ export async function misalignments(root, opts = {}) {
  * repositório inteiro, e isto roda em TODA abertura de sessão. Um aviso que custa um walk completo
  * a cada sessão é um aviso que alguém desliga.
  */
-export async function nextStepFor(root) {
+export async function nextStepFor(root, 
+/** `home` porque a decisão sobre as ferramentas mora nele - ver `mcpAwaitingApproval`. */
+opts = {}) {
     const locks = (await locksIn(root)).filter((l) => l.slug && !l.adopted);
     if (locks.length > 0)
         return null;
+    /** `true` só quando declarado e sem decisão; `null` (não sei) e `false` calam do mesmo jeito. */
+    const awaiting = (await mcpAwaitingApproval(root, opts.home ?? homedir()).catch(() => null)) === true;
     const measured = await readFile(join(root, "_synthesisui", "census.json"), "utf8").then(() => true, () => false);
     /**
      * MEDIDO E SEM SISTEMA INSTALADO SÃO DUAS HISTÓRIAS, e a frase antiga contava a errada.
@@ -646,14 +692,17 @@ export async function nextStepFor(root) {
      * `list --mine` primeiro porque o slug nasce no servidor: ele não está em nenhum arquivo daqui, e
      * chutá-lo seria pior que pedir para olhar.
      */
+    const awaits = awaiting ? { toolsAwaiting: true } : {};
     return measured
         ? {
+            ...awaits,
             sentence: "This repo has been measured and has no system installed here. If you already imported, the system is in your account: `synthesisui list --mine`, then `synthesisui add <slug>`.",
             headline: "Your system is already in your account. Bring it in here:",
             run: ["synthesisui list --mine", "synthesisui add <slug>"],
             why: "Re-measuring would cost minutes and change nothing the platform already knows.",
         }
         : {
+            ...awaits,
             sentence: 'This repo has no design system contract yet. Ask me: "import my design system."',
             headline: "Open a new agent session in this repo",
             open: await agentOpenCommands(root).catch(() => []),
@@ -716,9 +765,18 @@ export function renderNextStep(next, freshSession) {
             : fmt(list.length === 1
                 ? "This run moved {what}, and a new session is what reads it."
                 : "This run moved {what}, and a new session is what reads them.", { what: said })).map(paint.dim));
-        if (freshSession.mcp)
-            lines.push(...bodyWrapped(say("The project's tools ask for approval once - say yes.")).map(paint.dim));
     }
+    /**
+     * A LINHA DA APROVAÇÃO, UMA VEZ, PELO FATO OU PELO QUE ACABOU DE MOVER.
+     *
+     * Ela estava dentro do `if (freshSession)` e dependia de o MCP ter mudado NESTA rodada. O caso do
+     * dono é o contrário e é o mais comum a partir da segunda vez: a fiação já estava lá ("nothing to
+     * change - this environment is already current") e a aprovação continuava pendente. `next.toolsAwaiting`
+     * é o fato lido do estado; `freshSession.mcp` continua valendo para a rodada que acabou de
+     * declarar as ferramentas, quando ainda não há decisão nenhuma para ler.
+     */
+    if (next.toolsAwaiting || freshSession?.mcp)
+        lines.push(...bodyWrapped(say("The project's tools ask for approval once - say yes.")).map(paint.dim));
     return lines.join("\n");
 }
 /**
@@ -733,12 +791,35 @@ export function renderNextStep(next, freshSession) {
  */
 export async function reportWhatIsLeft(root, opts = {}) {
     const items = await misalignments(root, opts).catch(() => []);
-    if (items.length === 0) {
-        const next = await nextStepFor(root).catch(() => null);
-        if (next)
-            console.log(renderNextStep(next, opts.freshSession));
+    const next = await nextStepFor(root, {
+        ...(opts.home ? { home: opts.home } : {}),
+    }).catch(() => null);
+    /**
+     * A AÇÃO RECOMENDADA GANHA DO QUE SÓ SE RESOLVE DENTRO DELA - e a falta desta regra é a
+     * regressão que o dono leu na 0.16.365.
+     *
+     * Isto era um OU EXCLUSIVO: um desalinho qualquer e o bloco "Do this next" não saía. O aviso da
+     * aprovação pendente nasceu em 03/09 e é verdadeiro justamente no repo que acabou de rodar
+     * `connect` - foi ele que declarou as ferramentas. E num repo sem sistema instalado aquele é o
+     * ÚNICO desalinho possível: todos os outros vêm depois de um `.lock`, e o remoto devolve `null`
+     * sem lock. Então a instrução de abrir o agente não desapareceu às vezes; ela desapareceu SEMPRE,
+     * no único momento em que ela é a coisa que a pessoa procura na tela.
+     *
+     * A separação não esconde nada: o que se resolve no terminal continua saindo, embaixo da ação. O
+     * que se resolve dentro do agente vira a segunda metade da ação, que é o que ele é - a aprovação
+     * acontece na sessão que o passo 1 manda abrir.
+     */
+    const onTheTerminal = items.filter((m) => m.where !== "agent");
+    if (next) {
+        console.log(renderNextStep(next, opts.freshSession));
+        if (onTheTerminal.length > 0) {
+            console.log("");
+            console.log(describeMisalignments(onTheTerminal, "after"));
+        }
         return;
     }
+    if (items.length === 0)
+        return;
     console.log("");
     console.log(describeMisalignments(items, "after"));
 }

package/dist/copy/connect.pt-BR.js

@@ -87,6 +87,10 @@ register("pt-BR", {
     "This run moved {what}, and a new session is what reads them.": "Esta rodada moveu {what}, e é uma sessão nova que lê isso.",
     "A new session reads the wiring this run changed.": "Uma sessão nova lê a fiação que esta rodada mudou.",
     "The project's tools ask for approval once - say yes.": "As ferramentas do projeto pedem aprovação uma vez - diga sim.",
+    // ── a lista do que ainda está fora, quando ela é o que sobra ──
+    /** O rótulo que diz onde uma slash command se digita - ela não existe no prompt do terminal. */
+    "inside your agent session:": "dentro da sua sessão do agente:",
+    "then, to pick up where you left off:": "e depois, para voltar de onde você parou:",
     // ── os nomes do que moveu, usados dentro da frase acima ──
     "the checks": "as verificações",
     "the write check": "a verificação de escrita",

package/dist/doctor/scan.js

@@ -38,8 +38,23 @@ const IGNORE_LINE = /^\s*(import|@import|\/\/|\*|\/\*)/;
  * plain CSS values and Tailwind arbitrary values (`bg-[#2563eb]`).
  * `#` inside a URL fragment or an id selector is excluded by requiring a full
  * 3/6/8 digit run terminated by a non-hex character.
+ *
+ * `oklch()` ENTROU EM 03/09, e a ausência dela era a metade calada de uma lacuna maior.
+ *
+ * O QUE O CLIENTE GANHA: a cor que o Tailwind 4 escreve por padrão passa a ser contada como valor
+ * de design. Este regex alimenta TRÊS superfícies - o `observed` do censo, a lista "Values written
+ * by hand" do `doctor`, e o relatório do `hook` a cada escrita -, e as três eram cegas a ela.
+ *
+ * MEDIDO no menor caso possível, uma `@theme` com duas cores em oklch e uma em hex: o `declared`
+ * trazia as três, o `look` do componente trazia `background: oklch(...)`, e o `observed` trazia
+ * SÓ o `#ffffff` da mesma regra. Nas populações: 94 usos no `codelevel-ui`, 23 no `frontend-hub`,
+ * e zero no `observed` das três.
+ *
+ * Ler oklch aqui e não no motor de cor - ou o contrário - não entrega nada: o valor precisa ser
+ * VISTO pelo scanner e INTERPRETADO por `colorForm` para chegar a uma comparação. As duas metades
+ * entraram na mesma mudança porque meia jornada não é meio valor.
  */
-const COLOR = /#[0-9a-fA-F]{8}\b|#[0-9a-fA-F]{6}\b|#[0-9a-fA-F]{3}\b|rgba?\([^)]*\)|hsla?\([^)]*\)/g;
+const COLOR = /#[0-9a-fA-F]{8}\b|#[0-9a-fA-F]{6}\b|#[0-9a-fA-F]{3}\b|rgba?\([^)]*\)|hsla?\([^)]*\)|oklch\([^)]*\)/g;
 /**
  * THE QUOTE THAT MADE HALF THE DRIFT INVISIBLE.
  *

package/dist/install-marks.js

@@ -235,7 +235,14 @@ export const MATERIALISER_SINCE = "0.16.362";
  * "não lido" sobre um valor que o de hoje resolve - e o número é o que a pessoa lê para decidir
  * se adotou. O `!` de important (0.16.306) já tinha mudado a mesma contagem.
  */
-export const CHECKER_SINCE = "0.16.308";
+/**
+ * 0.16.308 -> 0.16.367 em 03/09: o hook passa a ver `oklch()`. O regex de cor do scanner era cego à
+ * forma, então um agente que escrevia `oklch(69.6% 0.17 162.48)` recebia SILÊNCIO mesmo com o
+ * `--color-mint-500` do próprio repositório nomeando aquele valor. Agora recebe a linha de sempre:
+ * `line 12  oklch(...) -> --color-mint-500`. Um hook pinado antes desta versão aconselha OUTRA
+ * coisa - nada -, que é a régua desta marca.
+ */
+export const CHECKER_SINCE = "0.16.367";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *
@@ -651,7 +658,14 @@ export const CHECKER_SINCE = "0.16.308";
  * QUEM NÃO É AFETADO: quem tem menos de 4 096 formas em todo grupo - `web-onboarding` já chegava
  * com 39 de 39. O `sync` daquele repositório não muda um byte.
  */
-export const READER_SINCE = "0.16.356";
+/**
+ * 0.16.366 -> 0.16.367 em 03/09: `oklch()` entra na leitura de cor. O regex do scanner passou a ver
+ * a forma (era cega no `observed`, no `doctor` e no `hook`) e `colorForm` passou a interpretá-la,
+ * mapeando o gamut por chroma em vez de clampar canal. Medido nos `looks`: 94 usos no
+ * `codelevel-ui` e 23 no `frontend-hub`, e ZERO no `observed` das três populações. Um censo tirado
+ * antes disto não tem aqueles valores na régua, e só um `sync` os traz.
+ */
+export const READER_SINCE = "0.16.367";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/package.json

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