synthesisui 0.16.364 → 0.16.366

package/dist/baseline-craft.js

@@ -0,0 +1,42 @@
+/**
+ * A NOTA DO SISTEMA DELE E AS TRÊS LENTES QUE A COMPÕEM, no fim de um import.
+ *
+ * O QUE O CLIENTE GANHA: ele fecha o import sabendo em que pé o sistema dele nasceu - a nota, e as
+ * três lentes que dizem POR QUE ela é aquela - sem abrir o navegador. Quem apaga e recria um
+ * sistema para comparar antes e depois tinha de abrir a tela ou rodar um script sobre o banco, e o
+ * número que mais interessa naquele momento é exatamente esse.
+ *
+ * OS NÚMEROS SÃO IMPRESSOS, NUNCA COMPOSTOS - e a razão foi medida duas vezes em 24/08, quando o
+ * resumo escrito pelo agente derrubou justamente a metade que tinha acabado de entrar. Este módulo
+ * não calcula nada: ele formata o que o servidor devolveu, pela mesma função que desenha a tela
+ * pós-import. Um número calculado em dois lugares tem duas chances de discordar de si mesmo.
+ *
+ * E TODA LINHA CARREGA O SEU DENOMINADOR. "Token Discipline 62" sozinho não é auditável; "62, on 41
+ * of your 62 components" é - e é a mesma frase que a tela mostra embaixo de cada barra.
+ */
+import { body, bodyWrapped, paint } from "./output.js";
+/**
+ * AS LINHAS DO BLOCO, ou vazio quando não há nota para dar.
+ *
+ * Vazio e não uma linha vazia: quem chama decide se imprime o título, e um bloco com cabeçalho e
+ * nada embaixo é pior que bloco nenhum.
+ */
+export function craftLines(craft) {
+    if (!craft)
+        return [];
+    if (craft.score === null) {
+        return bodyWrapped("No component of yours was read yet, so there is no line to draw. Your tokens came through - the components are next.").map(body);
+    }
+    const lines = [
+        body(`${paint.strong(`${craft.score}/100`)} on your ${craft.authored} component${craft.authored === 1 ? "" : "s"} - never on our kit, never on a demo.`),
+    ];
+    /**
+     * OS RÓTULOS ALINHADOS PELO MAIS LONGO, e a largura é medida e não estimada: os nomes chegam do
+     * servidor, então um padding fixo desalinharia no dia em que uma lente for renomeada lá.
+     */
+    const width = Math.max(...craft.lenses.map((l) => l.label.length));
+    for (const lens of craft.lenses) {
+        lines.push(body(`  ${lens.label.padEnd(width)}  ${paint.strong(String(lens.score).padStart(3))}  ${paint.dim(`on ${lens.measuredOn} of them`)}`));
+    }
+    return lines;
+}

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/commands/import.js

@@ -3,6 +3,7 @@ import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { anatomyFromSketch } from "../anatomy-from-sketch.js";
 import { applyAnatomyPatch, hasEdits, } from "../anatomy-patch.js";
 import { resolveAnatomy, resolveFlatParts, safePartName, } from "../anatomy-read.js";
+import { craftLines } from "../baseline-craft.js";
 import { PAGES_MAX, pageCompositionOf } from "../census-pages.js";
 import { readCredentials, readToken, resolveRegistry, sameRegistry, } from "../config.js";
 import { declaredElsewhere } from "../declared-elsewhere.js";
@@ -4524,6 +4525,22 @@ export async function runImport(opts) {
         console.log(body(paint.dim(`In the group ${payload.group}.`)));
     for (const note of payload?.notes ?? [])
         console.log(body(paint.dim(note)));
+    /**
+     * A NOTA COM QUE O SISTEMA DELE NASCEU, e as três lentes - ver `baseline-craft.ts`.
+     *
+     * AQUI E NÃO DEPOIS DO v2, porque o v2 argumenta com estes mesmos números: uma proposta que
+     * promete melhorar a disciplina de token precisa que a disciplina de hoje já esteja na tela.
+     * É a ordem que a tela pós-import usa, e ela é deliberada lá pelo mesmo motivo.
+     *
+     * O bloco cala sozinho quando não há nota - servidor anterior a esta versão, ou análise que não
+     * pôde rodar. Um cabeçalho sem número embaixo seria pior que o silêncio.
+     */
+    const craft = craftLines(payload?.quality);
+    if (craft.length > 0) {
+        console.log(section("The line your system starts on"));
+        for (const line of craft)
+            console.log(line);
+    }
     // What a v2 would be worth, in their own values. Said here because this is
     // where the person is standing, and because a number they can check beats an
     // invitation they have to trust.

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/package.json

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