synthesisui 0.16.413 → 0.16.414

package/dist/agent-wiring.js

@@ -159,7 +159,7 @@ async function wireHook(root, command) {
  * arquivo de um editor que a pessoa não usa, e é a primeira coisa que alguém apaga com raiva - a
  * mesma regra que já vale para o `AGENTS.md`.
  */
-async function wireMcpAt(root, version, rel) {
+async function wireMcpAt(root, rel) {
     const path = join(root, rel);
     const config = await readJson(path);
     const servers = (config.mcpServers ?? {});
@@ -212,16 +212,21 @@ async function wireMcpAt(root, version, rel) {
  * Os caminhos de MCP que este repo merece: sempre o do Claude Code, e o do Cursor quando `.cursor/`
  * já existe. Devolve o que foi escrito, por caminho, para o `connect` poder dizer os nomes.
  */
-async function wireMcp(root, version) {
+/**
+ * E NENHUM DOS TRÊS RECEBE VERSÃO, desde 10/09 - o parâmetro morreu quando o Codex passou a seguir
+ * a régua de `@latest` (ver `codex-mcp.ts`). Os escritores de JSON nunca a usaram: a decisão de
+ * 06/08 é que o MCP flutua. Um argumento que ninguém lê é o próximo a ser lido por engano.
+ */
+async function wireMcp(root) {
     const wrote = [];
     wrote.push({
         path: ".mcp.json",
-        status: await wireMcpAt(root, version, ".mcp.json"),
+        status: await wireMcpAt(root, ".mcp.json"),
     });
     if (await exists(join(root, ".cursor")))
         wrote.push({
             path: ".cursor/mcp.json",
-            status: await wireMcpAt(root, version, ".cursor/mcp.json"),
+            status: await wireMcpAt(root, ".cursor/mcp.json"),
         });
     /**
      * E O CODEX, quando `.codex/` já existe - a mesma regra de evidência que decide o Cursor e a casa
@@ -234,7 +239,7 @@ async function wireMcp(root, version) {
     if (await exists(join(root, ".codex")))
         wrote.push({
             path: ".codex/config.toml",
-            status: await wireCodexMcp(root, version),
+            status: await wireCodexMcp(root),
         });
     return wrote;
 }
@@ -256,11 +261,13 @@ let codexWas = null;
 export function codexPinBefore() {
     return codexWas;
 }
-async function wireCodexMcp(root, version) {
+async function wireCodexMcp(root) {
     const path = join(root, ".codex", "config.toml");
     const current = await readFile(path, "utf8").catch(() => null);
     const had = current != null && hasCodexBlock(current);
-    const next = withCodexBlock(current ?? "", version);
+    /** A MESMA pergunta que o escritor de JSON faz - ver `codexBlock`. */
+    const local = await exists(join(root, "node_modules", ".bin", "synthesisui"));
+    const next = withCodexBlock(current ?? "", local);
     if (current === next)
         return "already there";
     /**
@@ -292,7 +299,7 @@ export async function wireAgent(root, version, want) {
         session: want.hook
             ? await wireSessionStart(root, await alignCommand(root, version))
             : "skipped",
-        mcp: want.mcp ? await wireMcp(root, version) : "skipped",
+        mcp: want.mcp ? await wireMcp(root) : "skipped",
     };
 }
 /**

package/dist/codex-mcp.js

@@ -36,8 +36,10 @@ export function hasCodexBlock(text) {
 /**
  * A versão pinada dentro da nossa região - `null` quando não há região ou quando ela não pina.
  *
- * O `connect` usa isto para dizer de ONDE para onde a fiação andou, que é a diferença entre
- * "atualizei" e uma linha que a pessoa fecha sem ler.
+ * O `connect` usa isto para dizer de ONDE a fiação saiu, que é a diferença entre "atualizei" e uma
+ * linha que a pessoa fecha sem ler. Desde 10/09 a região nova nunca pina (ver `codexBlock`), então
+ * o que esta função encontra é sempre PASSADO - e é exatamente aí que ela vale mais: um arquivo que
+ * ainda diz `synthesisui@0.16.413` está preso naquele leitor, e a tela pode dizer que ele saiu.
  */
 export function pinnedInCodex(text) {
     const start = text.indexOf(BEGIN);
@@ -50,14 +52,36 @@ export function pinnedInCodex(text) {
 /**
  * A REGIÃO, montada. `args` em duas partes porque é assim que o Codex quer a linha de comando:
  * o executável em `command`, e o resto quebrado em array.
+ *
+ * A MESMA RÉGUA DE VERSÃO DO OUTRO ESCRITOR, e isto é um conserto de 10/09. Este bloco nascia
+ * PINADO na versão do `connect`, e o `.mcp.json` do Claude Code nasce em `@latest` desde 06/08 -
+ * duas ferramentas, o mesmo repositório, o mesmo servidor nosso, e respostas opostas sobre quando
+ * ele fica mais novo.
+ *
+ * A decisão está escrita em `agent-wiring.ts`, e vale para os dois pela mesma razão: *"um servidor
+ * MCP sobe UMA VEZ quando o editor abre a sessão e fica estável durante ela. Pinado, ele nunca
+ * ficava mais novo - e a regra que manda o agente comparar `ledger.cli` com a versão do servidor
+ * quase nunca disparava, porque os dois congelavam juntos no dia do `connect`"* (dono, 06/08). O
+ * hook é o caso oposto e continua pinado: ele resolve a CADA escrita, e ali flutuar custa 720ms-1,5s
+ * por edição e um comportamento que muda sob a pessoa.
+ *
+ * O QUE O CLIENTE PERCEBIA: o agente dele no Claude Code recebia o leitor publicado na sessão
+ * seguinte; o agente dele no Codex ficava na versão do dia em que ele rodou o `connect`, e nada na
+ * tela dizia que os dois estavam em versões diferentes.
+ *
+ * E O INSTALL LOCAL CONTINUA GANHANDO, também como no outro: quem tem o CLI no `node_modules`
+ * escolheu a versão, e `--no-install` respeita a escolha - inclusive a de quem seguiu a sugestão
+ * que o próprio `connect` imprime, de pôr o CLI nas `devDependencies`.
  */
-export function codexBlock(version) {
+export function codexBlock(local) {
     return [
         BEGIN,
         "# Managed by synthesisui. Edit outside this block; this region is rewritten on connect.",
         "[mcp_servers.synthesisui]",
         'command = "npx"',
-        `args = ["synthesisui@${version}", "mcp"]`,
+        local
+            ? 'args = ["--no-install", "synthesisui", "mcp"]'
+            : 'args = ["synthesisui@latest", "mcp"]',
         END,
     ].join("\n");
 }
@@ -73,8 +97,8 @@ export function codexBlock(version) {
  * perdeu. Aí a gente devolve o arquivo COMO ESTÁ: apagar até o fim seria destruir o que vem
  * depois, e é a mesma decisão que o `withHook` toma no perfil de shell.
  */
-export function withCodexBlock(text, version) {
-    const block = codexBlock(version);
+export function withCodexBlock(text, local) {
+    const block = codexBlock(local);
     if (!hasCodexBlock(text))
         return `${text.replace(/\n*$/, "")}\n\n${block}\n`.replace(/^\n+/, "");
     const start = text.indexOf(BEGIN);

package/dist/commands/connect.js

@@ -367,16 +367,13 @@ export async function connect(opts) {
                 ? `✓ ${one.path.padEnd(22)} ${fmt("{n} tools the agent can ask", { n: MCP_TOOL_COUNT })}`
                 : one.status === "updated"
                     ? /**
-                       * DUAS HISTÓRIAS DIFERENTES SOB O MESMO `updated`, e dizer a errada é pior que não
-                       * dizer: no Claude Code e no Cursor a entrada é SOLTA (`@latest`), então o que
-                       * mudou é ela parar de segurar um leitor velho. No Codex a entrada é PINADA numa
-                       * versão, e o que mudou é de qual para qual - a mesma correção que o hook recebeu
-                       * em 06/08, quando "already had it" escondia um pin antigo.
+                       * O QUE MUDOU É SEMPRE A MESMA COISA AGORA: a entrada parou de segurar um leitor
+                       * velho. As três ferramentas seguem a régua de 06/08 (ver `codexBlock`), então a
+                       * frase é uma - e o Codex só ganha uma metade a mais, porque ele é o único cujo
+                       * arquivo pode estar vindo de um PIN nosso, escrito antes de 10/09.
                        */
-                        one.path.endsWith(".toml")
-                            ? `✓ ${one.path.padEnd(22)} ${fmt(codexPinBefore()
-                                ? "the tools moved from {was} to this one"
-                                : "{n} tools the agent can ask", { was: codexPinBefore() ?? "", n: MCP_TOOL_COUNT })}`
+                        one.path.endsWith(".toml") && codexPinBefore()
+                            ? `✓ ${one.path.padEnd(22)} ${fmt("was pinned to {was} - now it follows the published reader", { was: codexPinBefore() ?? "" })}`
                             : `✓ ${one.path.padEnd(22)} ${say("unpinned - it follows the published reader")}`
                     : `· ${one.path.padEnd(22)} ${say("already had it")}`);
     }

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

@@ -39,7 +39,7 @@ register("pt-BR", {
     "· .claude/settings.json  the session check was already there": "· .claude/settings.json  a verificação de sessão já estava lá",
     // ── o MCP e as skills ──
     "{n} tools the agent can ask": "{n} ferramentas que o agente pode consultar",
-    "the tools moved from {was} to this one": "as ferramentas vieram da {was} para esta",
+    "was pinned to {was} - now it follows the published reader": "estava pinado na {was} - agora acompanha o leitor publicado",
     "unpinned - it follows the published reader": "solto - acompanha o leitor publicado",
     "already had it": "já estava lá",
     "already current": "já está em dia",

package/dist/install-marks.js

@@ -187,7 +187,20 @@
  * O que o cliente ganha ao rodar `upgrade`: os componentes que ele já tem voltam a ser reescritos
  * pelo materializador que respeita a edição dele em TODO comando, e não só em dois.
  */
-export const MATERIALISER_SINCE = "0.16.412";
+/**
+ * 0.16.412 -> 0.16.414 em 10/09: as ferramentas do sistema param de congelar no Codex. A região que
+ * a gente escreve em `.codex/config.toml` nascia PINADA na versão do `connect`, e o `.mcp.json` do
+ * Claude Code nasce solta desde 06/08 - o agente dele numa ferramenta recebia o leitor publicado na
+ * sessão seguinte, e na outra ficava no do dia em que ele rodou o comando. Medido no repositório do
+ * dono depois de um `connect` da 0.16.413: `@latest` num arquivo, `@0.16.413` no outro.
+ *
+ * São BYTES DIFERENTES na pasta dele, e o `upgrade` chama `wireAgent`: quem já instalou sai do pin
+ * rodando o comando, e a tela diz de qual versão ele saiu.
+ *
+ * O que o cliente ganha ao rodar `upgrade`: o agente dele no Codex volta a ler o interpretador
+ * publicado, em vez do que existia no dia em que ele conectou.
+ */
+export const MATERIALISER_SINCE = "0.16.414";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/package.json

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