synthesisui 0.16.140 → 0.16.145

package/dist/doctor/ci-format.js

@@ -0,0 +1,205 @@
+/**
+ * O DOCTOR NA PIPELINE - anotação na linha, e uma CATRACA em vez de um pedágio.
+ *
+ * A objeção mais dura que um Design System Lead cético faz a qualquer plataforma de governança é que
+ * ela vive numa terceira aba: se a checagem não está no PR, no linter, no autocomplete, o engenheiro
+ * ignora. O doctor já respondia metade disso - roda offline, sem login, em 1,8s sobre 2797 arquivos -
+ * e não tinha como falar a língua de um PR.
+ *
+ * O QUE FALTAVA MAIS QUE O FORMATO, e é o achado que decidiu esta peça: o doctor só reprova com
+ * `--strict`, e `--strict` num repo legado é vermelho no dia um. Um portão que fica vermelho para
+ * sempre é um portão que alguém contorna na segunda semana - é literalmente o "pedágio" que faz times
+ * criarem biblioteca paralela. Então o que entra na pipeline não é um portão: é uma CATRACA.
+ *
+ *     sem baseline    nunca reprova, e anota tudo como aviso
+ *     com baseline    reprova SÓ quando a conta subiu - no total ou em algum arquivo
+ *     --write-baseline  congela onde vocês estão hoje, e a dívida de ontem para de doer
+ *
+ * Um arquivo que piorou reprova mesmo quando o total caiu, de propósito: num monorepo o total esconde
+ * um time melhorando e outro regredindo, e a regressão é a única coisa que uma catraca existe para
+ * pegar.
+ *
+ * NADA AQUI FALA COM A REDE nem pede login. É a mesma decisão que mantém o hook instalado: uma
+ * checagem que telefona para casa é uma checagem que alguém desinstala.
+ */
+const byFileOf = (d) => {
+    const out = {};
+    for (const f of d.files)
+        if (f.findings.length > 0)
+            out[f.file] = f.findings.length;
+    return out;
+};
+/** O retrato de agora, para ser gravado e comparado depois. */
+export function baselineOf(d, meta) {
+    return {
+        baseline: 1,
+        at: meta.at,
+        ...(meta.cli ? { cli: meta.cli } : {}),
+        ...(meta.scope ? { scope: meta.scope } : {}),
+        totals: { drift: d.findings.length, phantoms: d.phantomUses },
+        byFile: byFileOf(d),
+    };
+}
+/**
+ * A conta subiu?
+ *
+ * `incomparable` existe porque comparar dois escopos diferentes produz uma regressão inventada - o
+ * dono mediu `packages/ui` e `apps/web-dashboard` no mesmo dia, e um deles tem 2,5x os arquivos do
+ * outro. Nesse caso a catraca NÃO reprova e diz por quê: reprovar por diferença de input é o alarme
+ * falso que ensina um time a passar `--no-verify`.
+ */
+export function compareToBaseline(d, base, now) {
+    const mine = byFileOf(d);
+    const regressed = [];
+    let improved = 0;
+    for (const [file, count] of Object.entries(mine)) {
+        const was = base.byFile[file] ?? 0;
+        if (count > was)
+            regressed.push({ file, was, now: count });
+    }
+    for (const [file, was] of Object.entries(base.byFile))
+        if ((mine[file] ?? 0) < was)
+            improved += 1;
+    const drift = { was: base.totals.drift, now: d.findings.length };
+    const phantoms = { was: base.totals.phantoms, now: d.phantomUses };
+    const scopeChanged = (base.scope ?? "") !== (now.scope ?? "");
+    return {
+        worse: !scopeChanged &&
+            (drift.now > drift.was ||
+                phantoms.now > phantoms.was ||
+                regressed.length > 0),
+        drift,
+        phantoms,
+        regressed: regressed.sort((a, b) => b.now - b.was - (a.now - a.was)),
+        improved,
+        ...(scopeChanged
+            ? {
+                incomparable: `the baseline was measured on ${base.scope ?? "the whole repo"} and this run read ${now.scope ?? "the whole repo"} - different inputs, so nothing is failed on the difference`,
+            }
+            : {}),
+    };
+}
+/** O que a mensagem de uma anotação diz, e é a mesma frase nos dois formatos. */
+function messageFor(f) {
+    return f.token
+        ? `${f.literal} is written by hand, and this project's system already names it: var(${f.token}). Use the token.`
+        : `${f.literal} is a ${f.kind} value written by hand, and the system has no name for it yet. Name it, or file a token request: npx synthesisui request token`;
+}
+/**
+ * ANOTAÇÕES DO GITHUB, que aparecem na linha exata do diff.
+ *
+ * Nenhuma Action é necessária: o GitHub lê estes comandos do stdout de qualquer step, então a
+ * integração inteira é uma linha no workflow deles. Uma Action publicada seria uma peça a mais para
+ * manter oferecendo exactamente isto.
+ *
+ * TUDO É `warning`, e nunca `error`: a severidade que reprova é o exit code, e ela é decidida pela
+ * catraca. Anotação vermelha em cima de dívida herdada é o mesmo pedágio de sempre, pintado de outra
+ * cor.
+ */
+export function githubAnnotations(d, cap = 200) {
+    const out = [];
+    /**
+     * O QUE TEM CONSERTO ÓBVIO VEM PRIMEIRO, porque o teto é real e ele decide o que chega ao PR.
+     *
+     * Um achado cujo token JÁ EXISTE é uma troca de uma linha; um valor que o sistema não nomeia é uma
+     * decisão de design. Ordenar assim faz o teto cortar a conversa difícil em vez do conserto fácil -
+     * e medido no repo do dono, sem ordem nenhuma as 200 anotações saíram todas de um diretório gerado.
+     */
+    const ranked = [...d.findings].sort((a, b) => a.token && !b.token ? -1 : b.token && !a.token ? 1 : 0);
+    for (const f of ranked.slice(0, cap)) {
+        const title = f.token
+            ? "Token exists for this value"
+            : "Design value not in the system";
+        /** `::` e `%` quebram o parser do GitHub, e uma anotação que não parseia desaparece calada. */
+        const clean = (s) => s
+            .replace(/%/g, "%25")
+            .replace(/\r/g, "%0D")
+            .replace(/\n/g, "%0A")
+            .replace(/::/g, ":");
+        out.push(`::warning file=${f.file},line=${f.line},title=${clean(title)}::${clean(messageFor(f))}`);
+    }
+    if (d.findings.length > cap)
+        out.push(`::notice::${d.findings.length - cap} more findings are in the report - annotations are capped at ${cap} so the log stays readable. Run \`npx synthesisui doctor --verbose\` locally for all of them.`);
+    return out;
+}
+/**
+ * SARIF 2.1.0, para quem já tem um pipeline de qualidade de código.
+ *
+ * É o formato que o code-scanning do GitHub, o SonarQube e as ferramentas de segurança já ingerem -
+ * então o achado entra na mesma caixa de entrada em que o time já olha, em vez de exigir uma nova.
+ * Mínimo e válido: `runs[].tool`, `results[]` com `ruleId`, `level`, `message`, `locations`.
+ */
+export function sarifOf(d, cli) {
+    const rules = [
+        {
+            id: "synthesisui/token-exists",
+            shortDescription: {
+                text: "A design value written by hand that the system already names",
+            },
+            help: {
+                text: "The project's own design system declares a token with this exact value. Using the literal means a later change to the token will not reach this line.",
+            },
+        },
+        {
+            id: "synthesisui/unnamed-value",
+            shortDescription: {
+                text: "A design value the system has no name for",
+            },
+            help: {
+                text: "Nothing in the system holds this value. Either it belongs in the system - file a token request - or it is deliberately one-off, which is a decision worth writing down.",
+            },
+        },
+    ];
+    return JSON.stringify({
+        $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+        version: "2.1.0",
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: "SynthesisUI doctor",
+                        ...(cli ? { version: cli } : {}),
+                        informationUri: "https://www.synthesisui.com",
+                        rules,
+                    },
+                },
+                results: d.findings.map((f) => ({
+                    ruleId: f.token
+                        ? "synthesisui/token-exists"
+                        : "synthesisui/unnamed-value",
+                    /** `warning` sempre: quem reprova é a catraca, não o achado. */
+                    level: "warning",
+                    message: { text: messageFor(f) },
+                    locations: [
+                        {
+                            physicalLocation: {
+                                artifactLocation: { uri: f.file },
+                                region: { startLine: f.line, snippet: { text: f.excerpt } },
+                            },
+                        },
+                    ],
+                })),
+            },
+        ],
+    }, null, 1);
+}
+/** O veredito da catraca em texto, para o log do CI - e ele lidera pela boa notícia. */
+export function describeVerdict(v) {
+    const lines = [];
+    if (v.incomparable) {
+        lines.push(`Baseline not comparable: ${v.incomparable}.`);
+        return lines;
+    }
+    lines.push(`Drift ${v.drift.was} → ${v.drift.now}${v.phantoms.was || v.phantoms.now ? ` · phantom tokens ${v.phantoms.was} → ${v.phantoms.now}` : ""}.`);
+    if (v.improved > 0)
+        lines.push(`${v.improved} file${v.improved === 1 ? "" : "s"} improved since the baseline.`);
+    if (v.regressed.length === 0) {
+        lines.push("Nothing regressed. The ratchet holds.");
+        return lines;
+    }
+    lines.push(`${v.regressed.length} file${v.regressed.length === 1 ? "" : "s"} got worse than the baseline:`);
+    for (const r of v.regressed.slice(0, 10))
+        lines.push(`  ${r.file}: ${r.was} → ${r.now}`);
+    lines.push("Fix those lines, or accept them into the baseline on purpose: npx synthesisui doctor --write-baseline");
+    return lines;
+}

package/dist/index.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { add } from "./commands/add.js";
 import { adopt } from "./commands/adopt.js";
 import { advise } from "./commands/advise.js";
+import { ci } from "./commands/ci.js";
 import { clean } from "./commands/clean.js";
 import { component } from "./commands/component.js";
 import { connect } from "./commands/connect.js";
@@ -17,6 +18,7 @@ import { login } from "./commands/login.js";
 import { mcp } from "./commands/mcp.js";
 import { refit } from "./commands/refit.js";
 import { request } from "./commands/request.js";
+import { status } from "./commands/status.js";
 import { sync } from "./commands/sync.js";
 import { template } from "./commands/template.js";
 import { upgrade } from "./commands/upgrade.js";
@@ -44,7 +46,7 @@ Usage - governance (deterministic, FREE):
   synthesisui adopt [--write]              turn the design system you ALREADY have into a contract
   synthesisui import [--scope <p>] [--usage <p>]  read what you already have and make it a system
                                            your agent follows - without touching your CSS
-  synthesisui connect                      wire your agent: the check as an editor hook, the system
+  synthesisui connect [--ci]                      wire your agent: the check as an editor hook, the system
                                            as MCP tools, and a contract that stops repeating itself
   synthesisui doctor [paths…] [--verbose]  audit for DRIFT: every design value written by hand, the
                                            token your system already has for it, coherence, and the
@@ -54,8 +56,16 @@ Usage - governance (deterministic, FREE):
                                            something no reader would change
   synthesisui request [component|token]    the queue of what your agent needed and the system
                                            refused to invent (--done <id> closes one)
-  synthesisui sync                         send the local record - checks, fixes, open requests -
-                                           to your system's dashboard (by hand, never automatic)
+  synthesisui sync                         re-measure this repo with the current reader and send it,
+                                           reusing the reading you already authored, plus the local
+                                           record - checks, fixes, open requests (--record-only skips
+                                           the measurement, --yes skips the overwrite question)
+  synthesisui doctor --fix [--dry]          replace every hand-written value your system already
+                                           names with the token, in place
+  synthesisui status                       where this project stands: installed version, last check,
+                                           the ratchet, open requests - local first, no login needed
+  synthesisui ci [--write]                 the two steps that put drift in your PR - annotations on
+                                           the line, and a ratchet that fails only on regression
   synthesisui hook                         the check itself; installed by connect, run by your editor
   synthesisui mcp                          the system as tools; installed by connect, run by your agent
 
@@ -227,6 +237,7 @@ async function main() {
                 version: CLI_VERSION,
                 hook: flags.hook !== false,
                 mcp: flags.mcp !== false,
+                ci: flags.ci === true,
             });
             return;
         case "hook":
@@ -250,8 +261,31 @@ async function main() {
                 // written last week does not break.
                 verbose: flags.verbose === true || flags.all === true,
                 laws: flags.laws === true,
+                /**
+                 * A PIPELINE - ver `ci-format.ts`. `--format` decide a língua, `--baseline` decide o que
+                 * reprova: sem ele nada reprova por dívida herdada, com ele reprova só a regressão.
+                 */
+                ...(flags.format === "github" || flags.format === "sarif"
+                    ? { format: flags.format }
+                    : {}),
+                ...(typeof flags.baseline === "string"
+                    ? { baseline: flags.baseline }
+                    : {}),
+                ...(flags.baseline === true ? { compareBaseline: true } : {}),
+                ...(flags.fix === true ? { fix: true } : {}),
+                ...(flags.dry === true ? { dry: true } : {}),
+                ...(flags["write-baseline"] === true ? { writeBaseline: true } : {}),
+                cli: CLI_VERSION,
             });
             break;
+        case "status":
+            /** A resposta do dia a dia no terminal - ver `commands/status.ts`. Local primeiro. */
+            await status({ dir, registry, cli: CLI_VERSION });
+            break;
+        case "ci":
+            /** A governança dentro do PR - ver `commands/ci.ts`. Imprime, ou grava com `--write`. */
+            await ci({ dir, write: flags.write === true });
+            break;
         case "gaps":
             /**
              * O LEDGER JÁ ESTÁ NO CENSO - isto não mede nada, tria.
@@ -422,8 +456,21 @@ async function main() {
             await clean({ dir, force: flags.force === true });
             break;
         case "sync":
-            // A versão que reporta o estado do repo - ver `repoStateOf`.
-            await sync({ dir, registry, cli: CLI_VERSION });
+            /**
+             * A versão que reporta o estado do repo - ver `repoStateOf` - e que MEDE: desde 05/08 o `sync`
+             * remede o repo com o leitor atual e reenvia, reusando a leitura já gravada. É o único comando
+             * do lado do cliente para fazer um conserto de leitura chegar.
+             *
+             * `--record-only` manda só o registro, e `--yes` não pergunta antes de sobrescrever receita
+             * escrita na tela. O default é medir e perguntar.
+             */
+            await sync({
+                dir,
+                registry,
+                cli: CLI_VERSION,
+                recordOnly: args.includes("--record-only"),
+                yes: args.includes("--yes"),
+            });
             break;
         case "request": {
             // `synthesisui request` lists; `request component --name x --for "..."`

package/dist/skill-import.js

@@ -11,8 +11,8 @@
  * CLI no longer has.
  */
 export const IMPORT_SKILL = `---
-name: import-design-system
-description: Turn a codebase the user ALREADY has into a SynthesisUI design system. Use when someone points at an existing repo, app or component library and asks to import it, adopt it, bring it in, or "make a design system from this" (e.g. "/import-design-system", "importa o meu packages/ui", "turn this app into a design system"). Drives the full pipeline - census → your reading → import → v2 proposal - and answers the questions arithmetic cannot.
+name: sui-import-ds
+description: Turn a codebase the user ALREADY has into a SynthesisUI design system. Use when someone points at an existing repo, app or component library and asks to import it, adopt it, bring it in, or "make a design system from this" (e.g. "/sui-import-ds", "importa o meu packages/ui", "turn this app into a design system"). Drives the full pipeline - census → your reading → import → v2 proposal - and answers the questions arithmetic cannot.
 ---
 
 # Import Design System
@@ -1287,4 +1287,4 @@ Say so if it comes up, rather than implying otherwise:
   link and check.
 `;
 /** Where it lands in the consumer's repo. */
-export const IMPORT_SKILL_PATH = ".claude/skills/import-design-system/SKILL.md";
+export const IMPORT_SKILL_PATH = ".claude/skills/sui-import-ds/SKILL.md";

package/dist/skill-init.js

@@ -0,0 +1,226 @@
+/**
+ * A SKILL DA PRIMEIRA CORRIDA, como o CLI a distribui.
+ *
+ * Mesmo motivo 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 - então divergência fica vermelha em vez de embarcar uma skill que descreve um fluxo
+ * que o produto não tem.
+ *
+ * E ela é instalada pelo `connect` junto com a de import, de propósito: uma skill que exige reiniciar
+ * o editor para aparecer é uma skill que ninguém usa na primeira corrida, que é a única em que ela
+ * serve (dono, 05/08).
+ */
+export const INIT_SKILL = `---
+name: sui-init
+description: The first run - wire the agent, choose what to import, and hand back a system that is already optimised. Use when somebody has just installed SynthesisUI and has no system yet ("/sui-init", "set me up", "começar", "importar meu projeto"). Asks everything up front, measures while asking, and ends in four lines.
+---
+
+# The first run
+
+One conversation, and at the end they have a design system built out of their own code, with our
+optimisations applied and a way back to the untouched version.
+
+The purpose that decides every tie below: **read their repository and give it back as recipes with
+visual, semantic and functional parity, without supposing and without inventing anything.**
+
+\`CLAUDE.md\` rules. When the two disagree, this file is the one that is out of date.
+
+---
+
+## THE SHAPE OF THIS RUN, AND WHY IT IS THIS SHAPE
+
+Four questions, asked before anything that needs an answer. Then silence, then four lines.
+
+\`\`\`
+1  environment      which agent they work in - and what that agent can actually get
+2  authorisation    may we optimise after importing, and which parts
+3  project          WHICH folder becomes the system (the only unavoidable choice)
+4  identity         name, primary, theme - each already answered by the census
+---- nobody waits from here on ----
+   import v1  ->  freeze v1  ->  apply what they authorised  ->  four lines
+5  offer            put the tokens back into their code
+\`\`\`
+
+**Every question is asked before the work, and the work starts during the questions.** A person who
+answers four things in ninety seconds and then watches one bar has had a good four minutes; the same
+person interrupted twice mid-silence has had a bad twenty (dono, 01/08).
+
+**What runs in parallel, precisely.** The UNSCOPED census - \`npx synthesisui import --dry\` - needs no
+answer and discovers the candidate projects, so start it the moment question 1 is on screen. The
+SCOPED census needs question 3, and no amount of wishing makes it earlier. Do not promise more
+parallelism than that: a progress bar waiting on a person is worse than a question.
+
+---
+
+## 1. ENVIRONMENT
+
+Ask, because it changes what you install and it changes what you promise. Do not pretend the answers
+are equivalent - they are not, and a Design System Lead spots that in one minute.
+
+\`\`\`
+Which agent do you work in?
+
+  Claude Code (recommended if you have it)
+      rules + 11 tools + THE CHECK: after every file write, a hook measures what you
+      wrote and hands the result back into the conversation. No other agent has this.
+  Cursor
+      rules (.cursor/rules) + the same 11 tools (.cursor/mcp.json). No post-write check -
+      Cursor has no hook that feeds context back, so the rules are read, not enforced.
+  Something else
+      rules in AGENTS.md, which most agents read. Tell me which one and I will say
+      honestly whether its tool format is one we know.
+\`\`\`
+
+**Never invent a config path.** If they name an agent whose format is not in that list, say so and
+write \`AGENTS.md\` only. Writing a file into the wrong place is worse than not writing it: it looks
+like support and delivers nothing.
+
+Then wire it, once, with the command that is already idempotent:
+
+\`\`\`
+npx synthesisui@latest connect
+\`\`\`
+
+## 2. AUTHORISATION - ONE QUESTION, THREE BOXES
+
+Ask it HERE, before the import, because it is the only way the end can be four lines instead of a
+negotiation.
+
+\`\`\`
+After I import, may I apply the deterministic fixes? Nothing here is AI - it is arithmetic,
+and your untouched version stays frozen either way.
+
+  [x] tokens & contrast   values that repeat become one named token; text that fails
+                          contrast gets its INK changed, never its background
+  [x] spacing             lengths off your own scale converge onto the step you named
+  [x] typography          sizes and weights land on your own scale
+\`\`\`
+
+All three checked by default. Two things must be said in the same breath, because a default that
+edits is only defensible with both:
+
+- **v1 is frozen before anything is applied.** It is a published version, it never moves, and
+  restoring it is one click.
+- **Value, never form.** Your axes, options, parts and layers are declarations - we do not touch
+  them. \`archetypeFidelity\` is excluded from this run on purpose: its fix once deleted the \`variant\`
+  and \`size\` a real \`Input\` declared (dono, 02/08).
+
+If they decline all three: fine, and say what they are choosing - the system arrives exactly as
+their code has it, and the optimisations wait on a button.
+
+## 3. PROJECT
+
+By now the unscoped census has finished, so this is a list and not a question in the dark. The CLI
+already ranks the candidates by how many tokens each declares - use its numbers, never your
+impression.
+
+\`\`\`
+Where should the system come from?
+
+  packages/ui (recommended)    114 files · 47% of its values already named ·
+                               92 tokens of their own · every app imports it
+  the whole repo               2797 files · 36% · the average of one dark app and
+                               two light ones, which is a diagnosis and not a system
+  apps/web-dashboard           the heaviest consumer, if you want one app's vocabulary
+\`\`\`
+
+**Do not ask which styling they use.** We measure it, and better than they can answer it: the census
+counts every form with a percentage and an example. Show it instead, and name what we cannot read:
+
+\`\`\`
+Measured across 2797 files: 46% Tailwind classes, 31% CSS Modules, 12% sx props.
+I read all three. What I do not read yet: styled-jsx, 3% - and I will say so in the report.
+\`\`\`
+
+A wrong answer from them would override a right measurement from us. That is the whole reason this is
+a statement and not a question.
+
+## 4. IDENTITY
+
+Name, primary, default theme, canvas. Every one of them is already answered by the census - ask them
+as separate selectable questions, recommendation first, evidence in one line. The full wording lives
+in the \`sui-import-ds\` skill; do not reinvent it here, and do not ask anything it does not.
+
+**Our kit is not a question.** A project with its own component library gets theirs alone.
+
+---
+
+## THE SILENT PART
+
+Now nobody is asked anything. In order:
+
+\`\`\`
+1  npx synthesisui import --scope <theirs> --usage <apps…>     measures with the answers
+2  the reading                                                  anatomy, rules, roles
+3  send it                                                      their v1 exists
+4  POST /api/registry/ds/<slug>/optimize                        freeze v1, apply what they said yes to
+       { "categories": ["tokens", "spacing", "typography"] }
+\`\`\`
+
+Step 4 is ONE call on purpose: it freezes the base and applies the fixes in the same request, so
+there is never a moment where an optimisation landed with no frozen version to go back to.
+
+To show the numbers BEFORE applying - useful when they hesitated on question 2 - the same route
+answers a probe and writes nothing:
+
+\`\`\`
+{ "probe": true, "categories": ["tokens"] }
+\`\`\`
+
+If they authorised nothing, skip step 4 entirely. Do not call it with an empty list to be tidy: it
+answers 400, and a 400 in a first run reads as a broken product.
+
+---
+
+## 5. THE FOUR LINES
+
+This is the whole point of the run. Four lines, their numbers, no adjectives.
+
+\`\`\`
+SignalUI is yours - 275 components and 92 of your own tokens, read out of packages/ui.
+
+v1 is frozen: your system exactly as your code has it today. It never moves.
+v2 is what you are looking at - the same system with 118 deterministic fixes: contrast on
+text only, lengths onto your own scale, near-identical colours unified.
+
+Back to v1 is one click: /dashboard/mine/signalui/publish
+\`\`\`
+
+**What must never be in those lines:** how many files we scanned, how long it took, which readers
+ran, what the ledger says. All of that is in the report and none of it is what somebody wants in the
+first minute of owning a system.
+
+**What must always be there:** the count of their components, the count of their own tokens, and the
+way back.
+
+## 6. THE OFFER
+
+One question, and only if there is something to offer - the doctor already knows the number.
+
+\`\`\`
+340 hand-written values in your code have a token in your system now.
+Want me to replace them? It only touches values your system names, and you read the diff.
+
+    npx synthesisui@latest doctor --fix
+\`\`\`
+
+If the number is zero, say nothing. An offer with no subject is noise, and this run ends better
+short.
+
+---
+
+## WHAT THIS RUN NEVER DOES
+
+- **Never asks a question the census answers.** Styling, coverage, which files exist, how many
+  components - those are measurements, and asking invites a wrong answer to beat a right one.
+- **Never installs a file for an agent they did not name.** \`.cursor/\` in a repo that has no Cursor
+  is the first thing somebody deletes angrily.
+- **Never applies an optimisation without a frozen v1**, and never reports one without the way back.
+- **Never claims parity between agents.** The post-write check exists in one of them. Saying
+  otherwise is the kind of sentence that ends a trial.
+- **Never ends long.** If the last screen needs scrolling, the run failed at the last step.
+`;
+export const INIT_SKILL_PATH = ".claude/skills/sui-init/SKILL.md";

package/package.json

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