synthesisui 0.16.219 → 0.16.222

package/dist/commands/align.js

@@ -7,6 +7,7 @@ import { readToken, resolveRegistry } from "../config.js";
 import { unsentEvents } from "../doctor/ledger.js";
 import { CHECKER_SINCE, installedBehind, MATERIALISER_SINCE, READER_SINCE, } from "../install-marks.js";
 import { measuredScope } from "../measured-scope.js";
+import { SKILLS } from "../skills.js";
 /**
  * QUAL CLI MEDIU O CENSO EM DISCO - e era o `reader`, um inteiro, até 11/08.
  *
@@ -150,6 +151,36 @@ opts = {}) {
              */
             run: "npx synthesisui sync",
         });
+    /**
+     * A SKILL QUE ESTE CLI TEM E ESTE REPO NÃO - e sem isto ela nunca chegaria.
+     *
+     * `connect` é idempotente e atualiza sozinho, mas ninguém roda um comando de novo sem motivo: uma
+     * skill nova ficava esperando o acaso. Aqui ela vira uma linha do alinho, que é a única coisa que
+     * fala com a pessoa sem ela pedir.
+     *
+     * Compara o CONTEÚDO e não só a existência: uma skill velha descreve um fluxo que este CLI já não
+     * tem, e isso é pior que não ter skill nenhuma - quem lê não tem como perceber.
+     */
+    const installedSkills = await Promise.all(SKILLS.map((skill) => readFile(join(root, skill.path), "utf8").catch(() => null)));
+    /**
+     * E SÓ FALA COM QUEM JÁ TEM ALGUMA - senão isto vira o alarme que ensina uma palavra nova a quem
+     * não pediu.
+     *
+     * Um repositório sem skill nenhuma nunca ligou o agente, e pode nem usar Claude Code. Dizer a essa
+     * pessoa que "uma skill está faltando" é nomear uma ausência que ela escolheu, e `align` é a única
+     * superfície que fala sem ser chamada - a regra dela é ficar calada no estado saudável.
+     *
+     * Com uma instalada, o silêncio passa a ser o erro: ela ligou o agente, e uma skill nova ficaria
+     * esperando o acaso de alguém rodar `connect` de novo.
+     */
+    const staleSkills = SKILLS.filter((skill, i) => installedSkills[i] !== skill.source).map((skill) => skill.label);
+    if (installedSkills.some((have) => have != null) && staleSkills.length > 0)
+        out.push({
+            says: staleSkills.length === 1
+                ? `${staleSkills[0]} is missing or older than this CLI - it is a skill your agent can invoke, and it is not here.`
+                : `${staleSkills.length} skills are missing or older than this CLI (${staleSkills.join(", ")}) - your agent can invoke them, and they are not here.`,
+            run: "npx synthesisui connect",
+        });
     /**
      * SÓ O QUE NÃO SUBIU - ver `unsentEvents`. Isto contava o arquivo inteiro, e como o ledger é
      * append-only e o `sync` manda tudo (a plataforma deduplica), a linha nunca mais saía da tela e o

package/dist/commands/component.js

@@ -6,7 +6,7 @@ import { generateComponentFiles } from "../component-codegen.js";
 import { readProjectConfig, resolveRegistry } from "../config.js";
 import { hasInteractiveTemplate, interactiveTemplate, } from "../interactive-templates.js";
 import { body, section, snippet } from "../output.js";
-import { findCollision, reactMajorOf, readInstalledConvention, } from "../project-facts.js";
+import { findCollision, reactMajorOf, readInstalledConvention, readInstalledScheme, } from "../project-facts.js";
 import { fetchComponent, RegistryError } from "../registry.js";
 /**
  * Writes the shared `cn.ts` next to the components, built from THIS project's
@@ -157,7 +157,7 @@ export async function component(slug, name, opts) {
              * it, so the TSX and the stylesheet in the same folder agree by
              * construction. Falling back to disk keeps an older registry working.
              */
-            res.classNames ?? (await readInstalledConvention(root, slug)));
+            res.classNames ?? (await readInstalledConvention(root, slug)), res.name, await readInstalledScheme(root, slug));
             for (const file of files) {
                 await writeFile(join(compDir, file.filename), file.code, "utf8");
             }

package/dist/commands/connect.js

@@ -6,8 +6,7 @@ import { resolveRegistry } from "../config.js";
 import { body, paint, section, snippet } from "../output.js";
 import { readShellAnswer, rememberShellNo } from "../shell-answer.js";
 import { existingRc, hasHook, pinnedInHook, rcPathFor, shellFrom, shellSnippet, withHook, } from "../shell-hook.js";
-import { IMPORT_SKILL, IMPORT_SKILL_PATH } from "../skill-import.js";
-import { INIT_SKILL, INIT_SKILL_PATH } from "../skill-init.js";
+import { SKILLS } from "../skills.js";
 import { add } from "./add.js";
 import { reportWhatIsLeft } from "./align.js";
 import { ci } from "./ci.js";
@@ -293,24 +292,19 @@ export async function connect(opts) {
      * something change" - so nobody has to remember a second command.
      */
     /**
-     * AS DUAS SKILLS, e o `/sui-init` é a que importa mais aqui: é a PRIMEIRA CORRIDA, e uma skill que
+     * AS TRÊS SKILLS, e o `/sui-init` é a que importa mais aqui: é a PRIMEIRA CORRIDA, e uma skill que
      * só aparece depois de reiniciar o editor não serve para a primeira corrida de ninguém. Ela vem no
-     * mesmo `connect` que ainda vai pedir o reinício - então quando a pessoa reabre, as duas existem.
+     * mesmo `connect` que ainda vai pedir o reinício - então quando a pessoa reabre, as três existem.
+     *
+     * A TERCEIRA É DE MANUTENÇÃO, e ela é de outra natureza: as duas primeiras são de ENTRADA e rodam
+     * uma vez. `/sui-adapt` responde a pergunta do dia seguinte - *"isso aqui está de acordo com o meu
+     * design system?"* -, apontando para um componente, toda semana ou depois de mexer em alguma coisa.
+     *
+     * Ela quase ficou de fora daqui, e teria sido o erro de sempre: uma skill que só existe no NOSSO
+     * repositório é uma skill que só nós rodamos, e o caso de uso inteiro dela é o cliente rodando
+     * sozinho. Meia jornada não é meio valor.
      */
-    const skills = [
-        {
-            path: INIT_SKILL_PATH,
-            source: INIT_SKILL,
-            label: "/sui-init",
-            what: "the first run, start to finish",
-        },
-        {
-            path: IMPORT_SKILL_PATH,
-            source: IMPORT_SKILL,
-            label: "/sui-import-ds",
-            what: "the import, orchestrated",
-        },
-    ];
+    const skills = SKILLS;
     /**
      * A PASTA VELHA SAI, e isto é obrigatório numa renomeação de skill distribuída.
      *

package/dist/commands/doctor.js

@@ -130,6 +130,20 @@ export async function* walkAll(roots) {
  *  and the recipes `add` put next to them in `design-system.json`. Those
  *  recipes are why the component pass can exist at all - a linter has no idea
  *  what `ds-button` promised. */
+/**
+ * COMO CADA PEDIDO SE LÊ NUMA LINHA - e o `else` desta expressão mentia.
+ *
+ * Ela dizia `component "<nome>"` para tudo que não fosse token, então um pedido de REGRA aparecia no
+ * doctor como se fosse um componente pedido. Uma tela que rotula errado é pior que uma que não
+ * rotula: quem lê decide em cima do rótulo.
+ */
+function requestLabel(r) {
+    if (r.kind === "token")
+        return `token ${r.value} as ${r.name}`;
+    if (r.kind === "rule")
+        return `rule "${r.name}"`;
+    return `component "${r.name}"`;
+}
 export async function loadSystem(root) {
     const dsDir = join(root, "_synthesisui", "ds");
     let slugs;
@@ -941,7 +955,7 @@ export async function doctor(opts) {
             console.log("");
             console.log(section("What your agent asked for"));
             for (const r of requests.slice(0, 8)) {
-                console.log(body(`  ${r.id}  ${r.kind === "token" ? `token ${r.value} as ${r.name}` : `component "${r.name}"`}${r.area === "platform" ? "  [platform]" : ""}`));
+                console.log(body(`  ${r.id}  ${requestLabel(r)}${r.area === "platform" ? "  [platform]" : ""}`));
                 console.log(body(`          for: ${r.purpose}`));
                 if (r.considered)
                     console.log(body(`          considered: ${r.considered}`));

package/dist/commands/generate.js

@@ -2,7 +2,7 @@ import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { generateComponentFiles } from "../component-codegen.js";
 import { readProjectConfig, resolveRegistry } from "../config.js";
-import { reactMajorOf, readInstalledConvention } from "../project-facts.js";
+import { reactMajorOf, readInstalledConvention, readInstalledScheme, } from "../project-facts.js";
 import { postGenerate, RegistryError } from "../registry.js";
 /** PascalCase para o hint de import (course-card → CourseCard). */
 function pascalName(name) {
@@ -74,7 +74,7 @@ export async function generate(description, opts) {
         const files = generateComponentFiles(slug, res.name, res.recipe, res.css, version, config.styles, await reactMajorOf(root), 
         // Read off the installed document: a generated component lands in the same
         // project as the stylesheet it has to match.
-        await readInstalledConvention(root, slug));
+        await readInstalledConvention(root, slug), res.name, await readInstalledScheme(root, slug));
         for (const file of files) {
             await writeFile(join(compDir, file.filename), file.code, "utf8");
         }

package/dist/commands/mcp.js

@@ -200,6 +200,29 @@ const TOOLS = [
             required: ["value", "name", "purpose"],
         },
     },
+    {
+        name: "request_rule",
+        description: "File a rule request when this component does something the system's doctrine does not cover, and you had to decide alone. Read `system_doctrine` first: if a rule already answers it, follow it instead of filing. This is for the case with no rule - what the rule would say, and the case that asked for it. Do NOT invent a convention and move on; a decision that lives only in one file is not a decision of the system.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "What the rule would say, in one line: 'a card that opens a dialog carries the trigger, never the panel'",
+                },
+                purpose: {
+                    type: "string",
+                    description: "The case that asked for it - what you were building when no rule answered.",
+                },
+                considered: {
+                    type: "string",
+                    description: "Which existing rules you read and why they did not answer.",
+                },
+                file: { type: "string", description: "Where the case lives." },
+            },
+            required: ["name", "purpose"],
+        },
+    },
 ];
 /**
  * QUANTAS FERRAMENTAS ESTE SERVIDOR SERVE, lido da lista.
@@ -1037,6 +1060,24 @@ cli) {
                 ? `Filed as ${r.id} and routed to the synthesisui platform team - the system's contract already promises this and the shipped css does not deliver it. No one needs to act: it closes itself when an update lands. Keep the quiet base meanwhile.`
                 : `Filed as ${r.id}. Do not add the token yourself - the request shows up in \`synthesisui doctor\` for a person to decide.`);
         }
+        case "request_rule": {
+            /**
+             * SEM TRIAGEM AUTOMÁTICA, e de propósito.
+             *
+             * `request_token` sabe rotear para a plataforma quando o contrato do sistema já promete o
+             * nome - é uma pergunta que a máquina responde. "Isto deveria ser uma regra?" não é: ela é a
+             * decisão de quem é dono do sistema, e roteá-la sozinho seria inventar a resposta em vez de
+             * abrir a pergunta.
+             */
+            const r = await fileRequest(root, {
+                kind: "rule",
+                name: String(args.name ?? ""),
+                purpose: String(args.purpose ?? ""),
+                considered: args.considered ? String(args.considered) : undefined,
+                file: args.file ? String(args.file) : undefined,
+            });
+            return text(`Filed as ${r.id}. Do not adopt the convention as if it were a rule - it shows up in \`synthesisui doctor\` and travels to the system's queue, for the owner to make it a rule or decline it.`);
+        }
         default:
             return text(`No tool named ${name}.`, true);
     }

package/dist/commands/refit.js

@@ -3,7 +3,7 @@ import { basename, join } from "node:path";
 import { generateComponentFiles } from "../component-codegen.js";
 import { readProjectConfig, resolveRegistry } from "../config.js";
 import { body, section, snippet } from "../output.js";
-import { reactMajorOf, readInstalledConvention } from "../project-facts.js";
+import { reactMajorOf, readInstalledConvention, readInstalledScheme, } from "../project-facts.js";
 import { fetchComponent, postRefit, postSaveComponent, RegistryError, } from "../registry.js";
 /** Slugs INSTALLED under `_synthesisui/ds/` (a `.lock` marks a real install -
  *  a folder holding only refit artifacts doesn't count). */
@@ -133,7 +133,7 @@ export async function refit(file, opts) {
     if (config.target === "next") {
         const compDir = join(root, config.componentsDir, res.name);
         await mkdir(compDir, { recursive: true });
-        const files = generateComponentFiles(slug, res.name, res.recipe, res.css, saved.version, config.styles, await reactMajorOf(root), await readInstalledConvention(root, slug));
+        const files = generateComponentFiles(slug, res.name, res.recipe, res.css, saved.version, config.styles, await reactMajorOf(root), await readInstalledConvention(root, slug), res.name, await readInstalledScheme(root, slug));
         for (const f of files) {
             await writeFile(join(compDir, f.filename), f.code, "utf8");
         }

package/dist/commands/request.js

@@ -1,5 +1,5 @@
 import { resolve } from "node:path";
-import { closeRequest, fileRequest, readRequests } from "../doctor/requests.js";
+import { closeRequest, fileRequest, KINDS, readRequests, } from "../doctor/requests.js";
 import { body, section } from "../output.js";
 /**
  * `synthesisui request` - the queue of what the agent needed and was refused.
@@ -12,6 +12,12 @@ import { body, section } from "../output.js";
  * Closing is deliberately explicit. A request nobody got to is still a
  * request; nothing here expires.
  */
+/** Como cada tipo se lê numa linha - um lugar, três telas. */
+const labelOf = (r) => r.kind === "token"
+    ? `token ${r.value} as ${r.name}`
+    : r.kind === "rule"
+        ? `rule "${r.name}"`
+        : `component "${r.name}"`;
 export async function request(opts) {
     const root = resolve(opts.dir ?? process.cwd());
     if (opts.done) {
@@ -29,7 +35,7 @@ export async function request(opts) {
             return;
         }
         for (const r of all) {
-            console.log(body(`  ${r.id}  ${r.kind === "token" ? `token ${r.value} as ${r.name}` : `component "${r.name}"`}`));
+            console.log(body(`  ${r.id}  ${labelOf(r)}`));
             console.log(body(`          for: ${r.purpose}`));
             if (r.considered)
                 console.log(body(`          considered: ${r.considered}`));
@@ -40,14 +46,23 @@ export async function request(opts) {
         console.log(body("Close one: synthesisui request --done <id>"));
         return;
     }
-    if (opts.kind !== "component" && opts.kind !== "token") {
-        console.log(`Unknown kind "${opts.kind}" - component or token.`);
+    if (!KINDS.has(opts.kind)) {
+        console.log(`Unknown kind "${opts.kind}" - component, token or rule.`);
         return;
     }
+    /**
+     * UMA REGRA PRECISA DO CASO, e é por isso que ela exige `--for` como as outras.
+     *
+     * "Isto deveria ser uma regra" sem o caso que a motivou é uma opinião. Com o caso, quem decidir do
+     * outro lado tem o que a doutrina não cobria e onde isso apareceu - que é a diferença entre uma
+     * fila que vira decisão e uma que vira backlog.
+     */
     if (!opts.name || !opts.purpose || (opts.kind === "token" && !opts.value)) {
         console.log(opts.kind === "token"
             ? "A token request needs --value, --name and --for."
-            : "A component request needs --name and --for.");
+            : opts.kind === "rule"
+                ? "A rule request needs --name and --for - what the rule would say, and the case that asked for it."
+                : "A component request needs --name and --for.");
         return;
     }
     const r = await fileRequest(root, {

package/dist/commands/upgrade.js

@@ -7,7 +7,7 @@ import { readProjectConfig, resolveRegistry } from "../config.js";
 import { diffLocalDocuments, localChangelogMarkdown, } from "../document-diff.js";
 import { installedBehind, MATERIALISER_SINCE } from "../install-marks.js";
 import { body, section, snippet } from "../output.js";
-import { reactMajorOf, readInstalledConvention } from "../project-facts.js";
+import { reactMajorOf, readInstalledConvention, readInstalledScheme, } from "../project-facts.js";
 import { fetchChangelog, fetchComponent, fetchDesignSystem, RegistryError, } from "../registry.js";
 import { add } from "./add.js";
 import { reportWhatIsLeft } from "./align.js";
@@ -300,7 +300,7 @@ export async function upgrade(asked, opts) {
                 // Both were missing here, and `upgrade` is the command that REWRITES
                 // components somebody already has: without the convention it would have
                 // taken a working component and stripped its styles.
-                await reactMajorOf(root), res.classNames ?? (await readInstalledConvention(root, slug)));
+                await reactMajorOf(root), res.classNames ?? (await readInstalledConvention(root, slug)), res.name, await readInstalledScheme(root, slug));
                 for (const file of files) {
                     await writeFile(join(componentsRoot, entry, file.filename), file.code, "utf8");
                 }

package/dist/component-codegen.js

@@ -192,12 +192,50 @@ function layerAxes(part, variants) {
     }
     return out;
 }
-/** The axes of a part: the ones it declares, plus the ones its layers read. */
+/**
+ * The axes of a NODE - root or part: the ones it declares, plus the ones its layers
+ * read. Both callers use this; a node that reads only `variants` is the reader that
+ * dropped 15 of his 19 components.
+ */
 function partAxesOf(part, variants) {
     const own = axesOf(part.variants ?? {});
     const keys = new Set(own.map((a) => a.key));
     return [...own, ...layerAxes(part, variants).filter((a) => !keys.has(a.key))];
 }
+/**
+ * THE AXES OF THE COMPONENT ITSELF - and an axis nothing styles is still his API.
+ *
+ * `axesOf` drops an axis whose every option block is empty, which is right for a
+ * recipe we generated: there the option IS the styles, so an empty one is noise we
+ * invented. On a recipe we READ it is the opposite. His `Card` declares
+ * `variant: default | full-border | left-border` and this document carries no
+ * declarations for any of the three - the axis is a fact about HIS component that
+ * we failed to read the look for, and dropping the prop would silently narrow the
+ * API his own call sites already use.
+ *
+ * So the prop and the `data-variant` ship. The missing look is a reading gap, and
+ * it is already counted as one - `gaps` and the ledger say so with a number, which
+ * is the honest place for it. Ten of his components sat in exactly this state.
+ */
+function rootAxes(recipe) {
+    const fromLayers = partAxesOf(recipe, recipe.variants);
+    const seen = new Set(fromLayers.map((a) => a.key));
+    const declared = [];
+    for (const [axis, options] of Object.entries(recipe.variants ?? {})) {
+        const keys = Object.keys(options);
+        if (keys.length === 0 || seen.has(axis))
+            continue;
+        declared.push({
+            key: axis,
+            prop: camel(axis),
+            attr: kebab(axis),
+            boolean: keys.every((k) => k === "true" || k === "false"),
+            styledFalse: keys.includes("false"),
+            options: keys,
+        });
+    }
+    return [...fromLayers, ...declared];
+}
 function axesOf(variants) {
     const axes = [];
     for (const [axis, options] of Object.entries(variants ?? {})) {
@@ -489,17 +527,196 @@ function declToTailwind(prop, value) {
     }
     return [arbitrary(prop, value)];
 }
-const STATE_PREFIX = {
-    hover: "hover:",
-    focus: "focus:",
-    focusVisible: "focus-visible:",
-    active: "active:",
-    disabled: "disabled:",
+/**
+ * TAILWIND'S OWN WORD FOR A STATE, WHEN IT HAS ONE - and a mechanical rule when it
+ * does not, because a hand-written table would be a table of LIBRARIES.
+ *
+ * The contract's `STATE_SELECTORS` is a closed vocabulary of about thirty states,
+ * and most of them are attribute-shaped on purpose: `pressed` is how @base-ui
+ * spells it, `highlighted` is the option the arrow keys are on, `startingStyle` is
+ * an enter animation. Naming each one here by hand would rot the moment the
+ * contract grows a thirty-first, and the CLI cannot import the contract (it ships
+ * standalone), so a mirror would be a second copy to keep in step.
+ *
+ * The rule instead: a state Tailwind already has a variant for uses that word;
+ * everything else becomes `data-[<kebab>]:`, which is exactly the selector the
+ * compiler emits for it. New state in the contract, no edit here.
+ */
+const TW_NATIVE = new Set([
+    "hover",
+    "active",
+    "checked",
+    "disabled",
+    "empty",
+    "even",
+    "first",
+    "indeterminate",
+    "invalid",
+    "last",
+    "odd",
+    "open",
+    "placeholder",
+    "read-only",
+    "required",
+    "target",
+    "visited",
+    "after",
+    "before",
+]);
+/**
+ * WHERE ONE STATE HAS MORE THAN ONE SPELLING, ALL OF THEM SHIP.
+ *
+ * `disabled` is `:disabled` on a real control, `[aria-disabled]` on an accessible
+ * div and `[data-disabled]` in every headless kit - the compiler matches all three
+ * with one comma-joined rule, and picking one here would be picking a library. In
+ * utilities that costs one extra class per declaration, on the handful of states
+ * that actually have two grammars.
+ */
+const TW_ALSO = {
+    disabled: ["aria-disabled:", "data-[disabled]:"],
+    checked: ["aria-checked:", "data-[checked]:"],
+    open: ["aria-expanded:", "data-[open]:"],
+    selected: ["aria-selected:", "data-[selected]:"],
 };
+/** A state name → every Tailwind variant that expresses it. */
+function twStateVariants(state) {
+    // The compiler maps both to `:focus-visible` - a focus ring that also shows on
+    // a mouse click is the one thing nobody wants back.
+    if (state === "focus" || state === "focusVisible")
+        return ["focus-visible:"];
+    const word = kebab(state);
+    const native = TW_NATIVE.has(word) ? [`${word}:`] : [`data-[${word}]:`];
+    return [...native, ...(TW_ALSO[state] ?? [])];
+}
 function blockToTailwind(block, prefix = "") {
     return Object.entries(block).flatMap(([prop, value]) => declToTailwind(prop, value).map((cls) => `${prefix}${cls}`));
 }
+/** Every prefix combination one layer needs. A condition that cannot be
+ *  expressed returns no combination, and the layer is dropped rather than
+ *  emitted wrong - the same choice the compiler makes for an unknown state. */
+function twPrefixes(when, at, scheme, 
+/** On the ROOT, `within` IS its own state - the compiler says so explicitly. */
+asRoot) {
+    const groups = [];
+    /**
+     * THE SCHEME THE DOCUMENT OPENS IN IS THE RESTING LOOK, and getting this
+     * backwards is the one mistake here that inverts light and dark. His document
+     * opens DARK, so its 79 `scheme: dark` layers are what the component looks like
+     * at rest and they take no prefix at all; `light` is the one that needs the
+     * ancestor. `compile-css.ts` decides it the same way, off `docScheme`.
+     */
+    if (when.scheme && when.scheme !== scheme) {
+        // Both attributes, because that is what the compiled stylesheet matches and a
+        // real project puts one or the other on <html>.
+        groups.push([
+            `[[data-scheme=${when.scheme}]_&]:`,
+            `[[data-theme=${when.scheme}]_&]:`,
+        ]);
+    }
+    if (when.within) {
+        const own = twStateVariants(when.within);
+        if (own.length === 0)
+            return [];
+        groups.push(asRoot ? own : own.map((v) => `group-${v}`));
+    }
+    if (when.state) {
+        const own = twStateVariants(when.state);
+        if (own.length === 0)
+            return [];
+        groups.push(own);
+    }
+    for (const [axis, option] of Object.entries(when.variant ?? {})) {
+        // `!option` is every OTHER option - `not-data-[…]` is the utility for the
+        // `:not()` the compiler writes.
+        groups.push(option.startsWith("!")
+            ? [`not-data-[${kebab(axis)}=${option.slice(1)}]:`]
+            : [`data-[${kebab(axis)}=${option}]:`]);
+    }
+    if (at)
+        groups.push([`${at}:`]);
+    return groups.reduce((acc, group) => acc.flatMap((prefix) => group.map((g) => `${prefix}${g}`)), [""]);
+}
+function resolveNode(node, scheme, asRoot) {
+    const variants = {};
+    for (const [axis, options] of Object.entries(node.variants ?? {})) {
+        variants[axis] = {};
+        for (const [option, block] of Object.entries(options))
+            variants[axis][option] = { ...block };
+    }
+    const states = {};
+    for (const [state, block] of Object.entries(node.states ?? {}))
+        states[state] = { ...block };
+    const conditional = [];
+    for (const layer of node.layers ?? []) {
+        if (!layer.style || Object.keys(layer.style).length === 0)
+            continue;
+        const when = { ...(layer.when ?? {}) };
+        /**
+         * A LAYER FOR THE DOCUMENT'S OWN SCHEME CARRIES NO CONDITION - dropping the key
+         * here is what lets `{scheme: dark, variant: ocean}` land in the variant map as
+         * plain `ocean`, instead of being pushed into a compound prefix nobody needs.
+         */
+        if (when.scheme === scheme)
+            delete when.scheme;
+        const axes = Object.entries(when.variant ?? {});
+        const simpleVariant = !layer.at &&
+            !when.state &&
+            !when.within &&
+            !when.scheme &&
+            axes.length === 1 &&
+            !axes[0][1].startsWith("!");
+        const simpleState = !layer.at &&
+            !when.within &&
+            !when.scheme &&
+            axes.length === 0 &&
+            Boolean(when.state);
+        if (simpleVariant) {
+            const [axis, option] = axes[0];
+            variants[axis] = variants[axis] ?? {};
+            variants[axis][option] = { ...variants[axis][option], ...layer.style };
+            continue;
+        }
+        if (simpleState && when.state) {
+            states[when.state] = { ...states[when.state], ...layer.style };
+            continue;
+        }
+        for (const prefix of twPrefixes(when, layer.at, scheme, asRoot))
+            conditional.push({ prefix, style: layer.style });
+    }
+    /**
+     * AND THE TOGGLE HAS TO BE ABLE TO UNDO THE RESTING LOOK.
+     *
+     * A part reads as `base: bg-white` + a `dark` layer; on a dark document that
+     * layer is correct bare, but bare it also wins when somebody flips to light. So
+     * every property a resting-scheme layer overrides gets its BASE value back under
+     * the other scheme's ancestor - the same rule `compile-css.ts` applies, and
+     * without it the flip is one-way.
+     */
+    const alt = scheme === "dark" ? "light" : "dark";
+    for (const layer of node.layers ?? []) {
+        if (layer.when?.scheme !== scheme)
+            continue;
+        if (layer.when?.state || layer.when?.within)
+            continue;
+        const restore = {};
+        for (const prop of Object.keys(layer.style ?? {}))
+            if (node.base?.[prop] != null)
+                restore[prop] = node.base[prop];
+        if (Object.keys(restore).length === 0)
+            continue;
+        for (const prefix of [
+            `[[data-scheme=${alt}]_&]:`,
+            `[[data-theme=${alt}]_&]:`,
+        ])
+            conditional.push({ prefix, style: restore });
+    }
+    return { variants, states, conditional };
+}
+/** The classes every compound condition contributes, in layer order. */
+const conditionalClasses = (resolved) => resolved.conditional.flatMap((c) => blockToTailwind(c.style, c.prefix));
 function tailwindClassList(recipe, 
+/** The node's states and compound conditions, already read off its layers. */
+resolved, 
 /** CSS properties a variant axis owns - see `variantOwnedProps`. */
 exclude) {
     const base = exclude
@@ -509,7 +726,10 @@ exclude) {
         ...blockToTailwind(base),
         // States keep everything: `hover:` and `disabled:` cannot collide with an
         // unprefixed variant class, so there is nothing to resolve.
-        ...Object.entries(recipe.states ?? {}).flatMap(([state, block]) => STATE_PREFIX[state] ? blockToTailwind(block, STATE_PREFIX[state]) : []),
+        ...Object.entries(resolved.states).flatMap(([state, block]) => twStateVariants(state).flatMap((prefix) => blockToTailwind(block, prefix))),
+        // Compound conditions last: they are the most specific thing the recipe says,
+        // and in utilities the later class is the one a reader expects to win.
+        ...conditionalClasses(resolved),
     ];
     return classes.join(" ");
 }
@@ -771,7 +991,16 @@ function emitCssMode(slug, name, recipe, version, props, convention,
 localName = name) {
     const { tag, attrs, voidEl } = elementFor(name, recipe);
     const el = asElement(tag, attrs, voidEl);
-    const axes = axesOf(recipe.variants);
+    /**
+     * THE ROOT READS ITS AXES THE SAME WAY ITS PARTS DO, which is the whole fix.
+     *
+     * `axesOf` alone keeps an axis only when the option's own block carries
+     * declarations - true for a recipe we generated, and false for every recipe we
+     * READ, where the block is empty and the look is in `layers`. The parts learned
+     * this on 04/08; the root was left on the old reader and 15 of his 19 components
+     * with an axis shipped with no prop for it.
+     */
+    const axes = rootAxes(recipe);
     const comp = pascal(localName);
     const propNames = axes.map((a) => a.prop);
     const tree = recipe.preview?.parts ?? [];
@@ -857,28 +1086,56 @@ ${parts.filter(Boolean).join("\n")}`;
 }
 function emitTailwindMode(slug, name, recipe, version, props, 
 /** The name it takes in THEIR project. The utilities stay the system's. */
-localName = name) {
+localName = name, 
+/** The scheme the document opens in - see `generateComponentFiles`. */
+scheme = "dark") {
     const { tag, attrs, voidEl } = elementFor(name, recipe);
     const el = asElement(tag, attrs, voidEl);
-    const axes = axesOf(recipe.variants);
+    const axes = rootAxes(recipe);
     const comp = pascal(localName);
+    const resolved = resolveNode(recipe, scheme, true);
     const variantConsts = axes
         .filter((a) => !a.boolean)
         .map((a) => {
         const entries = a.options
-            .map((o) => `  ${JSON.stringify(o)}: ${JSON.stringify(blockToTailwind(recipe.variants[a.key]?.[o] ?? {}).join(" "))},`)
+            .map((o) => `  ${JSON.stringify(o)}: ${JSON.stringify(blockToTailwind(resolved.variants[a.key]?.[o] ?? {}).join(" "))},`)
             .join("\n");
         return `const ${a.prop.toUpperCase()}: Record<string, string> = {\n${entries}\n};`;
     });
     const booleanConsts = axes
         .filter((a) => a.boolean)
-        .map((a) => `const ${a.prop.toUpperCase()} = ${JSON.stringify(blockToTailwind(recipe.variants[a.key]?.true ?? {}).join(" "))};`);
+        .map((a) => `const ${a.prop.toUpperCase()} = ${JSON.stringify(blockToTailwind(resolved.variants[a.key]?.true ?? {}).join(" "))};`);
     // Every property some axis controls leaves BASE, and the base value becomes
     // that axis's default - so exactly one class ever sets it and the prop
     // actually wins.
-    const owned = new Map(axes.map((a) => [a.prop, variantOwnedProps(recipe.variants, a)]));
+    const owned = new Map(axes.map((a) => [a.prop, variantOwnedProps(resolved.variants, a)]));
     const excluded = new Set([...owned.values()].flat());
-    const fallbackFor = (a) => JSON.stringify(blockToTailwind(Object.fromEntries(Object.entries(recipe.base).filter(([prop]) => (owned.get(a.prop) ?? []).includes(prop)))).join(" "));
+    /**
+     * `group-hover:` NEEDS A GROUP, and the root is the only node that can carry it.
+     *
+     * `within` is a state of the ROOT read from a PART - the idiom a real table row
+     * is built on, and the contract names the utility outright. Emitting
+     * `group-hover:` on the part while nothing marks the group is a class that
+     * matches nothing, which is the same silent nothing this whole file is about.
+     */
+    const needsGroup = Object.values(recipe.parts ?? {}).some((part) => (part.layers ?? []).some((layer) => layer.when?.within));
+    /**
+     * THE DEFAULT OPTION IS THE RESTING LOOK - which the destructuring already says.
+     *
+     * `{ variant }` undefined means the component IS its default, and on a READ
+     * recipe the base has no value for the property at all (his Button declares no
+     * `backgroundColor` in base - every one of the nine lives in a layer). Falling
+     * back to base alone therefore rendered the default variant as nothing. The
+     * compiler emits the default's layer bare for exactly this reason.
+     */
+    const fallbackFor = (a) => {
+        const fromBase = Object.fromEntries(Object.entries(recipe.base).filter(([prop]) => (owned.get(a.prop) ?? []).includes(prop)));
+        const preset = recipe.defaults?.[a.key];
+        const fromDefault = preset
+            ? (resolved.variants[a.key]?.[preset] ?? {})
+            : {};
+        return JSON.stringify(blockToTailwind({ ...fromBase, ...fromDefault }).join(" "));
+    };
     const clsParts = [
         "BASE",
         ...axes.map((a) => a.boolean
@@ -922,7 +1179,7 @@ ${dataAttrLines(axes)}${axes.length ? "\n" : ""}    `;
 import type { ${needsElementType ? `ElementType, ${props}` : props} } from "react";
 import { cn } from "../cn";
 
-const BASE = ${JSON.stringify(tailwindClassList(recipe, excluded))};
+const BASE = ${JSON.stringify([needsGroup ? "group" : "", tailwindClassList(recipe, resolved, excluded)].filter(Boolean).join(" "))};
 ${[...variantConsts, ...booleanConsts].join("\n")}
 
 type ${comp}Props = ${propsType(axes, tag, props, el.offersAs)};
@@ -965,8 +1222,19 @@ ${orderedParts
          * toggles data-active from its own state, which is how the GUIDE
          * documents the contract.
          */
-        const partVariantClasses = partAxes.flatMap((a) => a.options.flatMap((o) => blockToTailwind(part.variants?.[a.key]?.[o] ?? {}, `data-[${a.attr}=${o}]:`)));
-        const partCls = [tailwindClassList(part), ...partVariantClasses]
+        /**
+         * AND THE OPTION'S LOOK COMES OFF THE LAYERS TOO - the half of 04/08 that was
+         * left behind. The part got its prop and its `data-status` attribute, and the
+         * classes were read from `part.variants[axis][option]`, which on a read recipe
+         * is the empty block: the attribute shipped, nothing answered it, and the
+         * status colours of his card were still nowhere.
+         */
+        const partResolved = resolveNode(part, scheme, false);
+        const partVariantClasses = partAxes.flatMap((a) => a.options.flatMap((o) => blockToTailwind(partResolved.variants[a.key]?.[o] ?? {}, `data-[${a.attr}=${o}]:`)));
+        const partCls = [
+            tailwindClassList(part, partResolved),
+            ...partVariantClasses,
+        ]
             .filter(Boolean)
             .join(" ");
         /**
@@ -1020,7 +1288,24 @@ convention = DEFAULT_CONVENTION,
  *
  * Absent means the component keeps its own name, which is every caller today.
  */
-localName = name) {
+localName = name, 
+/**
+ * WHICH SCHEME THE DOCUMENT OPENS IN - `meta.scheme`, and the one input here that
+ * cannot be guessed without inverting light and dark.
+ *
+ * A layer for the document's own scheme is the RESTING look and takes no prefix;
+ * the other one hangs off a `[data-scheme]` ancestor. Read it backwards on a
+ * dark-native system and every dark value moves behind an attribute nothing sets,
+ * so the component arrives unpainted. `readInstalledScheme` answers it off the
+ * document on disk - the same one the stylesheet next to it came from, so the two
+ * can never disagree.
+ *
+ * REQUIRED, with no default, deliberately. `compile-css.ts` defaults to `"dark"`
+ * and a default here would agree with it - but it would also let a new caller ship
+ * without ever deciding, and an optional argument that can be forgotten is the
+ * shape this file has already been bitten by. `tsc` refuses the half-call instead.
+ */
+scheme) {
     const files = [];
     const props = propsTypeName(reactMajor);
     if (styles === "css") {
@@ -1033,7 +1318,7 @@ localName = name) {
     else {
         files.push({
             filename: `${localName}.tsx`,
-            code: `${emitTailwindMode(slug, name, recipe, version, props, localName)}\n`,
+            code: `${emitTailwindMode(slug, name, recipe, version, props, localName, scheme)}\n`,
         });
     }
     files.push({

package/dist/doctor/requests.js

@@ -22,6 +22,8 @@ import { join } from "node:path";
  * how a team shares a queue.
  */
 export const REQUESTS_FILE = "requests.jsonl";
+/** Os tipos que a fila aceita, num lugar só - ver `GapRequest.kind`. */
+export const KINDS = new Set(["component", "token", "rule"]);
 const path = (root) => join(root, "_synthesisui", REQUESTS_FILE);
 /** Stable-enough id from content: 6 chars, collision-safe at queue scale. */
 function idOf(kind, name, at) {
@@ -65,7 +67,14 @@ export async function readRequests(root) {
             continue;
         try {
             const r = JSON.parse(line);
-            if (r?.id && r.name && (r.kind === "component" || r.kind === "token"))
+            /**
+             * O FILTRO DA LEITURA - e ele é um dos três lugares onde um tipo novo some CALADO.
+             *
+             * Uma linha com `kind` desconhecido é descartada aqui sem erro, então acrescentar um tipo sem
+             * passar por este ponto produz um pedido que o agente arquiva, o arquivo guarda, e ninguém
+             * nunca lê.
+             */
+            if (r?.id && r.name && KINDS.has(r.kind))
                 out.push(r);
         }
         catch {

package/dist/install-marks.js

@@ -64,8 +64,14 @@
  * carrega - as regras de elemento da folha global dele. Elas viajavam no `design-system.json` desde
  * sempre e o arquivo que o agente é mandado ler não as citava, então seis regras adotadas no sistema
  * real eram invisíveis para quem ia escrever a próxima tela.
+ *
+ * 0.16.217 -> 0.16.220 em 13/08, e o SIM mais forte que esta marca já teve: o COMPONENTE que cai na
+ * pasta dele mudou. O codegen lia o estilo condicional só onde uma receita NOSSA o guarda, e uma
+ * receita LIDA guarda em `layers` - então 15 dos 19 componentes dele com eixo eram materializados sem
+ * a prop, e 104 das 207 condições sem expressão nenhuma. Um `upgrade` anterior a esta versão reescreve
+ * os componentes dele com a perda intacta.
  */
-export const MATERIALISER_SINCE = "0.16.217";
+export const MATERIALISER_SINCE = "0.16.220";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/project-facts.js

@@ -143,3 +143,31 @@ export async function readInstalledConvention(root, slug) {
         return DEFAULT_CONVENTION;
     }
 }
+/**
+ * WHICH SCHEME THE INSTALLED SYSTEM OPENS IN, read off the same document on disk.
+ *
+ * The twin of `readInstalledConvention`, and for the same reason: the document is
+ * the one the compiled stylesheet came from, so this can never disagree with the
+ * CSS sitting next to it.
+ *
+ * It decides whether a `scheme: dark` layer is the RESTING look or the alternative
+ * one - the whole difference between a component that arrives painted and one whose
+ * every dark value hides behind an attribute nothing sets. `"dark"` when the
+ * document cannot be read, which is what the compiler assumes when nobody says.
+ */
+export async function readInstalledScheme(root, slug) {
+    const dir = join(root, "_synthesisui", "ds", slug);
+    const version = await pinnedVersion(dir);
+    const raw = version
+        ? await readFile(join(dir, `v${version}`, "design-system.json"), "utf8").catch(() => "")
+        : "";
+    if (!raw)
+        return "dark";
+    try {
+        const doc = JSON.parse(raw);
+        return doc.meta?.scheme === "light" ? "light" : "dark";
+    }
+    catch {
+        return "dark";
+    }
+}

package/dist/skill-adapt.js

@@ -0,0 +1,195 @@
+/**
+ * A SKILL DE MANUTENÇÃO, como o CLI a distribui.
+ *
+ * Mesmo motivo do `skill-init.ts` e do `skill-import.ts`: o build é `tsc` e nada mais, então um `.md`
+ * precisaria de um passo de cópia que pode silenciosamente não rodar. Um módulo TypeScript não pode
+ * falhar em ser empacotado.
+ *
+ * ESTA É A FONTE. A cópia em `.claude/skills/` é o que o nosso editor lê, e o spec assere que as duas
+ * são idênticas.
+ *
+ * E ela é a TERCEIRA que o `connect` instala - as outras duas são de ENTRADA (primeira corrida,
+ * import). Esta responde a pergunta do dia seguinte, apontando para uma tela: *"isso aqui está de
+ * acordo com o meu design system?"*. Deixá-la fora do `connect` faria dela uma skill nossa, e o caso
+ * de uso que a motivou é o cliente rodando sozinho toda semana.
+ */
+export const ADAPT_SKILL = `---
+name: sui-adapt
+description: Confronta UM componente (ou uma página, ou uma pasta) contra o design system instalado e adapta o que der - cobertura de token medida, conserto mecânico proposto antes de escrever, e o que sobra classificado em "regra nova" ou "conserto local". Use quando alguém aponta para uma peça e pergunta se ela está de acordo com o sistema (ex. "/sui-adapt components/ui/card", "analisa esse componente aqui", "isso aqui segue o meu design system?"), como rotina semanal, ou logo depois de criar/alterar um componente. Mede antes de propor, propõe antes de escrever, e nunca arquiva pedido em nome de ninguém.
+---
+
+# Adaptar uma peça ao sistema
+
+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.**
+
+Esta skill é a ponta de manutenção. As outras duas que o cliente tem são de ENTRADA -
+\`sui-init\` e \`sui-import-ds\` transformam o repositório dele em sistema. Esta responde a
+pergunta do dia seguinte, que ele faz apontando para uma tela: *"isso aqui está de acordo
+com o meu design system?"*.
+
+\`CLAUDE.md\` manda. Quando os dois divergirem, este arquivo é que está velho.
+
+---
+
+## 0. O QUE ESTA SKILL NÃO FAZ
+
+Três limites, e cada um existe por um motivo que já custou alguma coisa:
+
+\`\`\`
+não escreve sem propor    é o repositório DELE. \`--fix --write\` sem confirmação é
+                          outra categoria de confiança, e uma skill que perde essa
+                          confiança não é rodada uma segunda vez
+não arquiva pedido        \`request\` fila uma decisão na plataforma. A skill MOSTRA o
+                          comando; quem roda é ele
+não inventa token, nome   um agente que cala um relatório fazendo o sistema crescer é
+nem regra                 pior que a deriva que ele veio medir
+\`\`\`
+
+## 1. O ALVO, E POR QUE O ESCOPO É DECISÃO DA SKILL
+
+Componente quase nunca é um arquivo. \`Card.tsx\` costuma vir com \`Card.css\`, \`Card.stories.tsx\`
+e às vezes um \`index.ts\` - e medir só o \`.tsx\` produz um número que mente por omissão: o css
+ao lado é justamente onde os valores à mão se escondem.
+
+\`\`\`
+1. resolva o alvo   o que ele apontou, ou o arquivo aberto, ou o que ele acabou de mexer
+2. suba para a PASTA quando o irmão existir (mesmo nome, extensão diferente)
+3. DIGA qual escopo você usou, com o número de arquivos
+\`\`\`
+
+Nunca meça os dois e escolha o maior. Diga o que mediu.
+
+## 2. MEÇA - e a medida é determinística, não sua
+
+Duas portas, mesma resposta. Use a que a sessão tiver:
+
+\`\`\`
+MCP        check_file { path }
+terminal   npx synthesisui doctor <alvo>
+\`\`\`
+
+O que volta, medido num componente real (\`ArticleCard\`, 13/08):
+
+\`\`\`
+  SignalUI v7 - 181 tokens, 1 file read
+  scope: packages/ui/src/lib/SignalUI/organisms/ArticleCard/ArticleCard.tsx
+
+  Token coverage  ░░░░░░░░░░░░░░░░░░░░░░░░    0%
+                  0 from the system, 2 by hand
+                  50% is one command away - 1 of those have a name waiting
+\`\`\`
+
+Três números, e eles já vêm separados por natureza:
+
+\`\`\`
+from the system   já usa o vocabulário. Nada a fazer
+have a name waiting   o sistema JÁ nomeia esse valor -> mecânico, é o passo 3
+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
+
+\`--fix\` mostra; \`--write\` escreve. Rode o primeiro, cole a saída, espere.
+
+\`\`\`
+npx synthesisui doctor <alvo> --fix
+\`\`\`
+
+\`\`\`
+  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.
+\`\`\`
+
+Ofereça exatamente três saídas, nesta ordem:
+
+\`\`\`
+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á
+\`\`\`
+
+\`--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.
+
+## 4. 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.
+
+\`\`\`
+MCP        system_doctrine
+terminal   as regras viajam no documento instalado (_synthesisui/ds/<slug>/doctrine.json)
+\`\`\`
+
+Leia as regras e confronte o componente com cada uma. Três respostas possíveis por regra,
+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
+\`\`\`
+
+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
+
+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:
+
+\`\`\`
+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".
+
+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.
+
+## 6. FECHE EM QUATRO LINHAS
+
+Sem prosa. O cliente precisa decidir, não auditar:
+
+\`\`\`
+<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
+\`\`\`
+
+Se nada mudou, diga isso e pare. Uma skill que sempre encontra trabalho é uma skill que
+inventa trabalho.
+
+## 7. ROTINA
+
+Ela foi desenhada para duas horas do dia, e a segunda é a que mais rende:
+
+\`\`\`
+semanal          "roda o sui-adapt no dashboard" - pega deriva antes de virar hábito
+depois de mexer  componente novo, ou alteração grande: rode ANTES do commit, enquanto a
+                 decisão ainda está quente e o conserto ainda é barato
+\`\`\`
+
+O hook (\`PostToolUse\`) já roda a metade determinística a cada escrita, calado quando não há
+o que dizer. Esta skill é o passo deliberado: ela junta o hook, a doutrina e a fila numa
+conversa só, e termina com o cliente decidindo - não com um relatório.
+`;
+export const ADAPT_SKILL_PATH = ".claude/skills/sui-adapt/SKILL.md";

package/dist/skills.js

@@ -0,0 +1,39 @@
+import { ADAPT_SKILL, ADAPT_SKILL_PATH } from "./skill-adapt.js";
+import { IMPORT_SKILL, IMPORT_SKILL_PATH } from "./skill-import.js";
+import { INIT_SKILL, INIT_SKILL_PATH } from "./skill-init.js";
+/**
+ * AS SKILLS QUE O CLI DISTRIBUI, numa lista só - e ela existe porque DOIS comandos precisam dela.
+ *
+ * `connect` escreve; `align` cobra o que falta. Enquanto a lista morava dentro do `connect`, o
+ * `align` não tinha como saber que existia uma terceira - e uma skill nova só chegava a quem, por
+ * conta própria, rodasse `connect` de novo. Ninguém roda um comando de novo sem motivo.
+ *
+ * É a lei 8 no caso mais barato dela: a lacuna existe, a gente sabe qual é, e dizer custa uma linha.
+ */
+export const SKILLS = [
+    {
+        path: INIT_SKILL_PATH,
+        source: INIT_SKILL,
+        label: "/sui-init",
+        what: "the first run, start to finish",
+    },
+    {
+        path: IMPORT_SKILL_PATH,
+        source: IMPORT_SKILL,
+        label: "/sui-import-ds",
+        what: "the import, orchestrated",
+    },
+    /**
+     * A DE MANUTENÇÃO, e ela é de outra natureza que as duas acima.
+     *
+     * As duas primeiras são de ENTRADA: rodam uma vez, e depois nunca mais. Esta responde a pergunta do
+     * dia seguinte, apontando para uma tela - *"isso aqui está de acordo com o meu design system?"* -,
+     * toda semana ou depois de mexer em alguma coisa. É a primeira que uma pessoa roda mais de uma vez.
+     */
+    {
+        path: ADAPT_SKILL_PATH,
+        source: ADAPT_SKILL,
+        label: "/sui-adapt",
+        what: "one component against the system, and what to do about it",
+    },
+];

package/package.json

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