synthesisui 0.16.180 → 0.16.183

package/dist/commands/align.js

@@ -1,6 +1,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+import { pinnedHookVersion } from "../agent-wiring.js";
 import { readToken, resolveRegistry } from "../config.js";
 import { unsentEvents } from "../doctor/ledger.js";
 import { measuredScope } from "../measured-scope.js";
@@ -152,6 +153,23 @@ opts = {}) {
             says: `the files under _synthesisui/ds/${lock.slug} were written by CLI ${lock.cli} and you are running ${cli} - the design system's version has not changed, but what this CLI writes into that folder has.`,
             run: "npx synthesisui upgrade",
         });
+    /**
+     * O HOOK, MEDIDO NELE MESMO - e não pelo `.lock`, que é um proxy que se move sozinho.
+     *
+     * A linha acima compara o CLI que escreveu a PASTA. Desde que o `upgrade` passou a rematerializá-la
+     * (07/08), ela volta a bater sem que a fiação tenha sido refeita: o `.lock` dizia 0.16.180 e o
+     * `PostToolUse` continuava pinado em 0.16.178, com o `status` anunciando "In step". Um alarme
+     * desligado por um conserto parcial é pior que alarme nenhum.
+     *
+     * `pinnedHookVersion` devolve `null` numa instalação local, onde o hook segue o `node_modules` e
+     * nunca está atrás por si.
+     */
+    const pinned = await pinnedHookVersion(root).catch(() => null);
+    if (cli && pinned && pinned !== cli)
+        out.push({
+            says: `the check that runs after every write is pinned to CLI ${pinned} and you are running ${cli} - your agent's edits are being checked by an older reader than the one measuring this repo.`,
+            run: "npx synthesisui upgrade",
+        });
     if (cli && lock.version == null)
         out.push({
             says: `"${lock.slug}" has no version recorded, so nothing can tell whether the CSS in this repo is the one the platform publishes.`,

package/dist/commands/status.js

@@ -140,12 +140,22 @@ export async function status(opts) {
         : `${owned.slug} on the platform did not come from an import, so there is no measurement to compare.`));
     if (remote.hasCensus)
         console.log(body(paint.dim("`synthesisui sync` measures this repo again with today's reader and sends it.")));
-    /** E a distância até o leitor publicado, com o comando que a fecha - ver `sync`. */
-    if (remote.publishedCli && opts.cli && remote.publishedCli !== opts.cli) {
-        console.log("");
-        console.log(body(`Your CLI is ${opts.cli} and ${remote.publishedCli} is published - a newer reader sees styles this one cannot.`));
-        console.log(paint.blue(snippet(["npx synthesisui@latest upgrade"])));
-    }
+    /**
+     * A DISTÂNCIA ATÉ O LEITOR PUBLICADO - e ela desce para o veredito, em vez de ser um parágrafo solto.
+     *
+     * Isto imprimia acima e o veredito abaixo dizia "In step", no MESMO comando: duas seções
+     * discordando com três linhas de distância (dono, 07/08). Um comando que se contradiz não é meio
+     * certo, é inutilizável - quem lê passa a não acreditar em nenhuma das duas.
+     *
+     * Não vira um item do `align`: o CLI subiu seis vezes num dia e nenhuma delas mudou um leitor, e a
+     * verificação de abertura tem que ficar muda nesses casos. Aqui é diferente - a pessoa PERGUNTOU.
+     */
+    const behindCli = remote.publishedCli && opts.cli && remote.publishedCli !== opts.cli
+        ? {
+            says: `your CLI is ${opts.cli} and ${remote.publishedCli} is published - a newer reader sees styles this one cannot.`,
+            run: "npx synthesisui@latest upgrade",
+        }
+        : null;
     /**
      * O QUE ESTÁ FORA DE ALINHO - e este comando era CEGO para isso.
      *
@@ -154,11 +164,14 @@ export async function status(opts) {
      * usar a mesma medição do gancho, então `align` deixa de ser algo que alguém precisa conhecer -
      * ele continua existindo, chamado pelo `SessionStart` e pelo terminal (dono, 07/08).
      */
-    const off = await misalignments(root, opts.cli ? { cli: opts.cli } : {});
+    const off = [
+        ...(await misalignments(root, opts.cli ? { cli: opts.cli } : {})),
+        ...(behindCli ? [behindCli] : []),
+    ];
     console.log("");
     if (off.length === 0) {
         console.log(section("In step"));
-        console.log(body(paint.faint("Nothing here is behind the system that governs it - version, css, rules and the measurement all line up.")));
+        console.log(body(paint.faint("Nothing here is behind the system that governs it - version, css, rules, the measurement and this CLI all line up.")));
         return;
     }
     console.log(section("Out of step"));

package/dist/commands/upgrade.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { pinnedHookVersion, wireAgent } from "../agent-wiring.js";
 import { generateComponentFiles } from "../component-codegen.js";
 import { readProjectConfig, resolveRegistry } from "../config.js";
 import { diffLocalDocuments, localChangelogMarkdown, } from "../document-diff.js";
@@ -115,6 +116,27 @@ async function staleInstall(root, slug, version, base, cli) {
         why.push(`these files were written by CLI ${lock.cli}`);
     return why.length > 0 ? `${why.join(", ")} - re-materializing` : null;
 }
+/**
+ * A FIAÇÃO DO AGENTE, refeita quando ela ficou para trás.
+ *
+ * `upgrade` diz que traz para o dia tudo que está instalado aqui, e a pasta do DS é só metade: o hook
+ * `PostToolUse` é PINADO numa versão, então ele não anda sozinho. Em 07/08 o primeiro `upgrade` com o
+ * papel novo gravou `cli: 0.16.180` no `.lock` e deixou o hook em 0.16.178 - e como a verificação
+ * comparava o `.lock`, o `status` passou a dizer "In step" com a fiação duas versões atrás. Uma
+ * promessa pela metade que ainda por cima desliga o alarme.
+ *
+ * `wireAgent` é um merge idempotente: quando já está na versão certa, não escreve nada.
+ */
+async function rewireIfBehind(root, cli) {
+    if (!cli)
+        return;
+    const pinned = await pinnedHookVersion(root).catch(() => null);
+    if (!pinned || pinned === cli)
+        return;
+    await wireAgent(root, cli, { hook: true, mcp: true }).catch(() => null);
+    console.log(`↻ the check after every write moved from ${pinned} to ${cli}`);
+    console.log("  Reopen your editor session - hooks are read at startup.");
+}
 async function theOnlyInstalled(root) {
     const dsDir = join(root, "_synthesisui", "ds");
     const entries = await readdir(dsDir, { withFileTypes: true }).catch(() => []);
@@ -165,6 +187,7 @@ export async function upgrade(asked, opts) {
                 setupHints: false,
                 ...(opts.cli ? { cli: opts.cli } : {}),
             });
+            await rewireIfBehind(root, opts.cli);
             await reportWhatIsLeft(root, opts.cli ? { cli: opts.cli } : {});
             return;
         }

package/dist/doctor/style-ledger.js

@@ -83,6 +83,7 @@ export function buildLedger(cli, seen) {
             files: 0,
             because: BECAUSE[reason],
             examples: [],
+            unreadable: [],
             seenFiles: new Set(),
         };
         group.uses += 1;
@@ -94,6 +95,30 @@ export function buildLedger(cli, seen) {
                 line: f.line,
                 text: f.text.replace(/\s+/g, " ").trim().slice(0, 160),
             });
+        /**
+         * SÓ `shape-not-read`, E SÓ TEXTO DISTINTO - as duas restrições vieram de medir, não de supor.
+         *
+         * DAS QUATRO RAZÕES, uma só é alcançável por um leitor novo. `value-not-read` diz que a forma FOI
+         * lida e o valor está fora das escalas deles - texto não ensina nada a leitor nenhum. `computed`
+         * é montado em runtime e não existe na fonte. `component-not-admitted` é o portão, não a leitura.
+         * Sobra `shape-not-read`: "nenhum leitor desta versão entende esta forma", que é exatamente a
+         * frase que um leitor novo responde.
+         *
+         * E TEXTO DISTINTO, porque a primeira versão disto reprovou no spec do repo vivo: guardar todo
+         * fragmento deu 723 215 bytes no dashboard dele, contra um teto de 65 536. Oito mil cópias da
+         * mesma string não ensinam mais que uma - o que um leitor precisa é da variedade de FORMAS.
+         *
+         * O teto de 512 é declarado e não mudo: `uses` continua contando tudo, então a diferença entre o
+         * contado e o que viajou é visível em vez de silenciosa.
+         */
+        if (reason === "shape-not-read" &&
+            group.unreadable.length < 512 &&
+            !group.unreadable.some((u) => u.text === f.text))
+            group.unreadable.push({
+                file: f.file,
+                line: f.line,
+                text: f.text.replace(/\s+/g, " ").trim().slice(0, 400),
+            });
         groups.set(key, group);
     }
     return {

package/package.json

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