synthesisui 0.16.423 → 0.16.425

package/dist/commands/add.js

@@ -47,6 +47,12 @@ const IGNORED = [
     /** O que a última medição viu, para a próxima dizer o que mudou - descreve ESTE clone. */
     ".last-sync.json",
     "not-expressed.md",
+    /**
+     * O MODO DELA - ver `mode.ts`. Commitado, ele barraria o time inteiro porque UMA pessoa ligou
+     * o bloqueio dela, e o aceite da etapa 06 é literal: *"a escolha de uma pessoa nunca barra
+     * outra"*. Esta lista reconcilia, então quem já está conectado também recebe a linha.
+     */
+    ".mode",
 ];
 const IGNORE_HEADER = "# Managed by synthesisui. The identity and the CSS are committed so a fresh\n" +
     "# clone is governed; the measurement and the local record are not, because\n" +

package/dist/commands/hook.js

@@ -1,9 +1,12 @@
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import { changedSince } from "../changed-files.js";
+import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
+import { checkContracts } from "../doctor/contract-check.js";
 import { appendEvent, ledgerPath } from "../doctor/ledger.js";
 import { diagnose, nameToWrite, scanSource } from "../doctor/scan.js";
 import { governs, ungovernedIn } from "../governed.js";
+import { readMode } from "../mode.js";
 import { namesRemoved, previousText, rulesTouchedBy, } from "../rule-touched.js";
 import { loadSystem } from "./doctor.js";
 const pass = () => ({ continue: true });
@@ -14,6 +17,28 @@ const speak = (context) => ({
         additionalContext: context,
     },
 });
+/**
+ * A RECUSA - e ela só existe porque a PRÓPRIA pessoa ligou o modo CONSUMIR.
+ *
+ * `continue: true` continua ali: interromper a sessão dela seria uma punição, e o que se recusa é
+ * a mudança, não o trabalho. `decision: "block"` é o campo com que este evento devolve uma recusa
+ * ao agente, e o motivo vai JUNTO como contexto pelo mesmo caminho de sempre - um cliente que
+ * ignore o primeiro campo ainda entrega a frase à pessoa, e um bloqueio que some é pior que
+ * bloqueio nenhum.
+ *
+ * O QUE ELA NÃO É: desfazer o arquivo. Esta checagem roda DEPOIS da escrita, então o que ela
+ * devolve é a recusa da mudança e o que usar no lugar - e a frase diz isso com todas as letras,
+ * em vez de sugerir que a plataforma reverteu alguma coisa.
+ */
+const refuse = (context) => ({
+    continue: true,
+    decision: "block",
+    reason: context,
+    hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: context,
+    },
+});
 /** Written after the hook's first report of any kind, and never read for anything
  *  else. Lives in our own directory, so removing the system removes the memory
  *  too. It is committed with `_synthesisui/`, which means the greeting is
@@ -67,6 +92,14 @@ const startClock = (root) => writeFile(ledgerPath(root), "", { flag: "a" }).catc
  * escrever é o que a pessoa tem em mente.
  */
 const AT_MOST = 3;
+/**
+ * QUANTOS ARQUIVOS ALÉM DO RELATÓRIO A RECUSA AINDA ALCANÇA - ver o laço no fim deste arquivo.
+ *
+ * O relatório tem teto porque ele é leitura de pessoa; a RECUSA tem teto porque ela é a promessa
+ * que ela ligou. Quarenta cobre uma rodada de trabalho de agente com folga e para antes de uma
+ * troca de árvore inteira virar quarenta leituras de arquivo.
+ */
+const REFUSAL_CEILING = 40;
 const markGreeted = (root) => writeFile(join(root, GREETED), "", "utf8").catch(() => { });
 /** One sentence, once per project. Addressed to the agent because the hook has
  *  no way to reach the person, and the person is who needs to know. */
@@ -153,8 +186,64 @@ async function amendment(root, rel, after, rules, names) {
         "Tell the person which it is: the rule changes, or this case is an exception worth recording.",
     ];
 }
-async function report(root, filePath) {
-    const { table, doctrines } = await loadSystem(root);
+/**
+ * O QUE ESTE ARQUIVO ESCREVEU QUE O SISTEMA DELA NÃO DECLARA - a régua da etapa 06.
+ *
+ * ELA É A MESMA NOS DOIS MODOS, e isto é a promessa inteira: a checagem sabe exatamente a mesma
+ * coisa em CONSUMIR e em CRIAR - que aquele eixo tem opções declaradas e que esta não é uma delas.
+ * O que muda é o que se FAZ com o que ela sabe.
+ *
+ * E ELA SÓ RODA QUANDO HÁ MODO. Sem modo, o comando é exatamente o que era antes desta etapa -
+ * nem esta leitura acontece. Um produto que passa a falar de composição para todo mundo porque
+ * uma pessoa ganhou um interruptor é ruído que ninguém pediu, e ruído é o que faz uma checagem
+ * ser desinstalada.
+ *
+ * A CHECAGEM É A QUE O `doctor` JÁ FAZ - `checkContracts`, uma fonte só. Ela é silenciosa por
+ * construção: um eixo que o contrato não declara não é checado, um componente que o sistema não
+ * carrega não é checado, e um nome sem origem legível não é cobrado de ninguém.
+ */
+async function composition(root, rel, src, documents, systemName, mode) {
+    if (documents.length === 0)
+        return [];
+    const tally = emptyTally();
+    scanComponentsInto(tally, rel, src, await internalSpecifiers(root));
+    const breaches = checkContracts(tallyToInventory(tally, 80), documents);
+    if (breaches.length === 0)
+        return [];
+    return [
+        `${rel} - ${systemName} does not declare ${breaches
+            .map((b) => `\`${b.axis}="${b.used}"\` on ${b.element}`)
+            .join(", ")}.`,
+        "",
+        ...breaches.map((b) => `  ${b.element} ${b.axis}: ${b.offered.join(", ")}`),
+        "",
+        ...(mode === "consume"
+            ? [
+                /**
+                 * A FRASE NÃO FINGE QUE DESFEZ NADA. Esta checagem roda depois da escrita, então o
+                 * arquivo está no disco - dizer "recusado" sem dizer o que fazer com o que já está lá
+                 * deixaria a pessoa achando que a plataforma reverteu por ela.
+                 */
+                "You asked for consume mode, so this is refused: the file is already written, and it needs one of the options above.",
+                "Use one of them, or ask the person for a new one - do NOT invent an option.",
+                /**
+                 * A SAÍDA VAI JUNTO COM A RECUSA - achado da revisão de DX no fecho.
+                 *
+                 * Quem lê isto é o agente, no meio de uma tarefa, e ele não tem como saber que o
+                 * bloqueio tem um interruptor. Uma recusa sem a porta de saída visível é o adversário
+                 * que `INV-HOOK-01` existe para não deixar nascer - mesmo sendo um adversário que a
+                 * própria pessoa ligou.
+                 */
+                "If this is not the work you meant to be doing, `npx synthesisui mode off` ends it.",
+            ]
+            : [
+                "Create mode, so this is recorded and not refused - you are growing the system.",
+                "If this option is meant to stay, tell the person, so it enters the system as a declared one.",
+            ]),
+    ];
+}
+async function report(root, filePath, mode) {
+    const { table, doctrines, documents } = await loadSystem(root);
     if (table.byName.size === 0)
         return null;
     /**
@@ -168,6 +257,15 @@ async function report(root, filePath) {
         return null;
     const rel = relative(root, filePath);
     const broke = await amendment(root, rel, src, doctrines.flatMap((doc) => doc.rules), table).catch(() => []);
+    /**
+     * A COMPOSIÇÃO SÓ É MEDIDA QUANDO ELA LIGOU UM MODO - ver `composition`.
+     *
+     * Guardada como todo o resto deste arquivo: um erro ao ler o tsconfig ou o documento custa a
+     * metade de composição do relatório, nunca a rodada.
+     */
+    const composed = mode
+        ? await composition(root, rel, src, documents, table.name ?? table.slug ?? "this system", mode).catch(() => [])
+        : [];
     const d = diagnose([scanSource(rel, src, table)]);
     const named = d.findings.filter((f) => nameToWrite(f));
     /**
@@ -197,11 +295,17 @@ async function report(root, filePath) {
         named: named.length,
         phantoms: phantoms.length,
     });
-    if (broke.length === 0 &&
+    /** O bloqueio de CONSUMIR é a única saída que recusa, e ele acompanha o relatório seja qual for. */
+    const block = mode === "consume" && composed.length > 0;
+    const say = (text) => ({ text, block });
+    if (composed.length === 0 &&
+        broke.length === 0 &&
         named.length === 0 &&
         phantoms.length === 0 &&
-        unnamed.length === 0)
-        return greet(root, rel);
+        unnamed.length === 0) {
+        const hello = await greet(root, rel);
+        return hello ? say(hello) : null;
+    }
     // A report IS the evidence the greeting exists to provide, so it counts as the
     // introduction. Otherwise a project whose first file had drift would get the
     // "it is live" sentence afterwards, telling somebody who just watched it work.
@@ -231,22 +335,34 @@ async function report(root, filePath) {
      * Ela é a mais cara de ignorar: um valor solto se conserta depois, e uma regra apagada vira o
      * próximo agente restaurando a serif citando a doutrina, com o dono achando que ele alucinou.
      */
-    if (broke.length > 0 && named.length === 0 && phantoms.length === 0)
-        return broke.join("\n");
+    if (composed.length === 0 &&
+        broke.length > 0 &&
+        named.length === 0 &&
+        phantoms.length === 0)
+        return say(broke.join("\n"));
     const sample = unnamed
         .slice(0, 3)
         .map((f) => `line ${f.line} ${f.literal}`)
         .join(", ");
-    if (broke.length === 0 && named.length === 0 && phantoms.length === 0)
-        return [
+    if (composed.length === 0 &&
+        broke.length === 0 &&
+        named.length === 0 &&
+        phantoms.length === 0)
+        return say([
             `${rel} - ${unnamed.length} value${unnamed.length === 1 ? "" : "s"} here ${unnamed.length === 1 ? "has" : "have"} no name in this system, and nothing to replace ${unnamed.length === 1 ? "it" : "them"} with: ${sample}${unnamed.length > 3 ? `, +${unnamed.length - 3} more` : ""}.`,
             "Do not invent a name - leave them, or ask the person what they would call it.",
-        ].join("\n");
+        ].join("\n"));
     /**
      * E QUANDO HÁ AS DUAS COISAS, a emenda lidera o relatório - mesma razão: ela é a que ninguém
      * conserta depois, e a lista de valores abaixo dela ensina a diferença entre deriva e emenda.
      */
+    /**
+     * E A COMPOSIÇÃO LIDERA QUANDO ELA EXISTE, pela mesma razão da emenda: em CONSUMIR ela é a única
+     * parte do relatório que RECUSA, e uma recusa escondida embaixo de uma lista de valores é uma
+     * recusa que ninguém lê.
+     */
     const lines = [
+        ...(composed.length > 0 ? [...composed, ""] : []),
         ...(broke.length > 0 ? [...broke, ""] : []),
         `${rel} - checked against ${table.name ?? table.slug}.`,
     ];
@@ -272,7 +388,7 @@ async function report(root, filePath) {
     if (phantoms.length > 0) {
         lines.push("", "Names this system does not declare. These look tokenized and apply nothing at all:", ...phantoms.slice(0, 20).map((p) => `  line ${p.line}  ${p.name}`), "", "Use a name the system has, or say which value you need and what you would call it. Do NOT invent a token.");
     }
-    return lines.join("\n");
+    return say(lines.join("\n"));
 }
 /**
  * O QUE O AGENTE ACABOU DE ESCREVER, pelo caminho que o cliente do agente nomeia.
@@ -306,6 +422,11 @@ export async function hook(opts) {
         return;
     }
     const ungoverned = await ungovernedIn(root);
+    /**
+     * O MODO QUE ELA LIGOU NESTE PROJETO - ver `mode.ts`. Uma leitura de arquivo pequeno, e a
+     * ausência (o caso de todo projeto que existe hoje) é o produto como ele sempre foi.
+     */
+    const mode = await readMode(root).catch(() => null);
     const named = namedInPayload(input);
     /**
      * A FERRAMENTA DE EDIÇÃO DIZ O ARQUIVO; QUALQUER OUTRA COISA PERGUNTA À ÁRVORE.
@@ -318,9 +439,9 @@ export async function hook(opts) {
     if (named) {
         const rel = relative(root, resolve(root, named));
         const body = governs(rel, ungoverned)
-            ? await report(root, join(root, rel)).catch(() => null)
+            ? await report(root, join(root, rel), mode).catch(() => null)
             : null;
-        process.stdout.write(`${JSON.stringify(body ? speak(body) : pass())}\n`);
+        process.stdout.write(`${JSON.stringify(body ? (body.block ? refuse(body.text) : speak(body.text)) : pass())}\n`);
         return;
     }
     const clock = await clockOf(root);
@@ -336,10 +457,17 @@ export async function hook(opts) {
         return;
     }
     const said = [];
+    /**
+     * UMA RECUSA EM QUALQUER ARQUIVO DA RODADA RECUSA A RODADA - e é o lado certo: um comando de
+     * shell que reescreve dez arquivos e acerta nove continua tendo escrito o décimo.
+     */
+    let block = false;
     for (const { rel } of changed.slice(0, AT_MOST)) {
-        const body = await report(root, join(root, rel)).catch(() => null);
-        if (body)
-            said.push(body);
+        const body = await report(root, join(root, rel), mode).catch(() => null);
+        if (!body)
+            continue;
+        said.push(body.text);
+        block = block || body.block;
     }
     /**
      * O QUE FICOU DE FORA É NOMEADO, e com o comando que o olha - ver `AT_MOST`.
@@ -349,6 +477,45 @@ export async function hook(opts) {
      * pelo nome é o que transforma uma perda silenciosa numa lacuna declarada (lei 8).
      */
     const rest = changed.slice(AT_MOST);
+    /**
+     * E EM CONSUMIR, O TETO DO RELATÓRIO NÃO É O TETO DA RECUSA - achado da revisão de QA no fecho,
+     * e ele falsificava a invariante inteira.
+     *
+     * O CASO MEDIDO: ela liga CONSUMIR, o agente escreve quatro arquivos por um comando de shell, e
+     * a quebra está no quarto. O corte de três deixava aquilo passar com um aviso de "não checado
+     * aqui" - que, para quem pediu um bloqueio, é um passe. E é exatamente a população para a qual o
+     * caminho da árvore de trabalho foi construído: em 12/09, toda edição em lote do `codelevel`
+     * passou por shell.
+     *
+     * O RELATÓRIO CONTINUA EM TRÊS, e é outra pergunta: trinta relatórios numa resposta só é o ruído
+     * que faz uma checagem ser desinstalada. O que sobe é só a RECUSA - a composição dos demais é
+     * medida, e o que ela encontra entra como a lista do que precisa voltar, não como trinta
+     * relatórios.
+     *
+     * O TETO DE SEGURANÇA existe porque um `git checkout` de uma branch inteira também chega aqui: a
+     * recusa cobre uma rodada de trabalho, não uma troca de árvore.
+     */
+    const refusals = [];
+    if (mode === "consume") {
+        const { table, documents } = await loadSystem(root).catch(() => ({
+            table: null,
+            documents: [],
+        }));
+        if (table && table.byName.size > 0) {
+            for (const { rel } of rest.slice(0, REFUSAL_CEILING)) {
+                const src = await readFile(join(root, rel), "utf8").catch(() => null);
+                if (src == null)
+                    continue;
+                const found = await composition(root, rel, src, documents, table.name ?? table.slug ?? "this system", "consume").catch(() => []);
+                if (found.length > 0)
+                    refusals.push(found.join("\n"));
+            }
+        }
+    }
+    if (refusals.length > 0) {
+        said.push(...refusals);
+        block = true;
+    }
     if (rest.length > 0)
         said.push([
             `${rest.length} more file${rest.length === 1 ? "" : "s"} changed in this command and ${rest.length === 1 ? "was" : "were"} not checked here: ${rest
@@ -362,5 +529,6 @@ export async function hook(opts) {
      * e esta linha cobre o caso em que todos os relatórios falharam na leitura.
      */
     await startClock(root);
-    process.stdout.write(`${JSON.stringify(said.length > 0 ? speak(said.join("\n\n")) : pass())}\n`);
+    const context = said.join("\n\n");
+    process.stdout.write(`${JSON.stringify(said.length === 0 ? pass() : block ? refuse(context) : speak(context))}\n`);
 }

package/dist/commands/mode.js

@@ -0,0 +1,48 @@
+import { resolve } from "node:path";
+import { modePath, readMode, writeMode } from "../mode.js";
+import { ensureGovernanceHome } from "./add.js";
+/**
+ * `synthesisui mode` - ela liga e desliga o bloqueio dela, do próprio terminal.
+ *
+ * SEM ARGUMENTO ELE RESPONDE, e nunca muda nada. Um comando que muda estado ao ser chamado sem
+ * argumento é um comando que alguém dispara para consultar e descobre, depois, que ligou algo.
+ *
+ * E O QUE ELE IMPRIME É O ESTADO LIDO DE VOLTA, nunca o que ele tentou escrever: um interruptor
+ * que parece ligado e não está é pior que um que recusa.
+ */
+const SAYS = {
+    consume: "consume - building with what this system already has. The check refuses an option the system does not declare, and tells you what it offers instead.",
+    create: "create - growing the system. The check reports and gets out of the way.",
+};
+const OFF = "no mode - nothing is blocked, which is how this worked before you had the choice.";
+export async function mode(opts) {
+    const root = resolve(opts.dir ?? process.cwd());
+    const asked = opts.wanted?.trim().toLowerCase();
+    if (!asked) {
+        const current = await readMode(root);
+        console.log(`\n${current ? SAYS[current] : OFF}\n`);
+        return;
+    }
+    if (asked !== "create" && asked !== "consume" && asked !== "off") {
+        console.log(`\n"${opts.wanted}" is not a mode. The three are: consume, create, off.\n`);
+        return;
+    }
+    /**
+     * A CASA ANTES DA ESCOLHA, e a frase abaixo depende disto para ser verdade.
+     *
+     * O DEFEITO QUE ISTO FECHA, achado na revisão de QA do fecho: este comando criava a pasta e
+     * gravava o modo, e nada reconciliava a lista de ignorados. Num clone conectado ANTES desta
+     * versão essa lista não tem `.mode` - então a pessoa ligava o bloqueio dela, commitava sem
+     * perceber, e a escolha de uma pessoa passava a barrar o time inteiro. O terminal, enquanto
+     * isso, imprimia *"local to this clone, never committed"*.
+     *
+     * `ensureGovernanceHome` cria a pasta e ACRESCENTA à lista o que falta - ela nunca reescreve o
+     * arquivo, então uma linha que a pessoa escreveu ali continua onde está.
+     */
+    await ensureGovernanceHome(root);
+    await writeMode(root, asked === "off" ? null : asked);
+    /** Lido DE VOLTA do disco - ver o cabeçalho. */
+    const now = await readMode(root);
+    console.log(`\n${now ? SAYS[now] : OFF}\n`);
+    console.log(`  ${modePath(root)} - local to this clone, never committed.\n`);
+}

package/dist/commands/sync.js

@@ -42,6 +42,21 @@ import { resolveReadParts, siblingProjects, takeCensus, } from "./import.js";
 export function draftLine(slug, base) {
     return `this went into your DRAFT - your repository still has what you installed. It reaches the disk once you publish${base ? `: ${base}/dashboard/mine/${slug}/publish` : ""}\n      then: npx synthesisui@latest upgrade ${slug}`;
 }
+/**
+ * O TRABALHO DELA FOI PARA A RAMIFICAÇÃO DELA, E ISSO SE DIZ - `INV-BRANCH-02`.
+ *
+ * O QUE O CLIENTE VIA SEM ISTO: `62 of 62 components written.` - a mesma frase de quem move a
+ * linha principal. Ela fecharia o terminal achando que o time recebeu, e descobriria o contrário
+ * num dia em que estivesse contando com aquilo. É a lacuna calada que a lei 8 proíbe: o cliente
+ * perdoa o que a gente diz que não faz, e não perdoa descobrir sozinho.
+ *
+ * A FRASE DIZ TRÊS COISAS, nesta ordem: onde o trabalho está, que ele está inteiro, e o que falta
+ * para alcançar o time. Sem a terceira ela é um aviso sem saída - e quem lê não tem o que fazer
+ * com ele.
+ */
+export function branchLine(slug, base) {
+    return `this went to YOUR branch, not to the main line your team installs - nothing of it was lost. It reaches them when whoever owns this system approves it${base ? `: ${base}/dashboard/mine/${slug}` : ""}`;
+}
 export function decisionLine(d, slug, 
 /** Onde o sistema dele vive - o `publish` mora lá, e sem o endereço a frase manda procurar. */
 base) {
@@ -629,6 +644,12 @@ export async function remeasure(args) {
     console.log("");
     console.log(section("Sent"));
     console.log(body(`${out.written ?? 0} of ${out.total ?? 0} components written.`));
+    /**
+     * E ONDE ELE CAIU, logo abaixo do número - porque é o número que ela leria como "o time
+     * recebeu".
+     */
+    if (out.landedOn === "branch")
+        console.log(body(paint.strong(branchLine(slug, base))));
     /**
      * O QUE VEIO DOS ARQUIVOS DELE, DITO - e antes de qualquer outra nota, porque é a única parte
      * desta saída que fala do trabalho que ELE acabou de fazer.

package/dist/index.js

@@ -22,6 +22,7 @@ import { list } from "./commands/list.js";
 import { login } from "./commands/login.js";
 import { logout } from "./commands/logout.js";
 import { mcp } from "./commands/mcp.js";
+import { mode } from "./commands/mode.js";
 import { refit } from "./commands/refit.js";
 import { request } from "./commands/request.js";
 import { status } from "./commands/status.js";
@@ -83,6 +84,10 @@ Usage - governance (deterministic, FREE):
                                            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 mode [consume|create|off]    consume: the check REFUSES an option your system does not
+                                           declare, and says what it offers instead. create: it
+                                           reports and gets out of the way. No argument answers
+                                           where you are. Local to this clone, never committed
   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
 
@@ -275,6 +280,12 @@ async function main() {
         case "hook":
             await hook({ dir });
             return;
+        /**
+         * O INTERRUPTOR DELA - ver `mode.ts`. Sem argumento ele RESPONDE, e só com um deles muda.
+         */
+        case "mode":
+            await mode({ dir, ...(args[0] ? { wanted: args[0] } : {}) });
+            break;
         // Long-lived: it owns stdin/stdout until the client closes the pipe, so
         // it must not be reached by anything that prints.
         case "mcp":

package/dist/install-marks.js

@@ -235,7 +235,7 @@
  * chama `wireAgent`, então rodar o comando é o caminho de volta - e ele só alarga a string que era
  * nossa, nunca um filtro que uma pessoa escreveu.
  */
-export const MATERIALISER_SINCE = "0.16.423";
+export const MATERIALISER_SINCE = "0.16.424";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *
@@ -366,7 +366,7 @@ export const COUNTED_DIFFERENTLY = "this run counts a value as named only when Y
  * utility, um arquivo escrito inteiro no vocabulário do sistema recebia zero. A contagem em si é a
  * outra marca - ver `COUNTED_DIFFERENTLY_SINCE`, que sobe no mesmo diff.
  */
-export const CHECKER_SINCE = "0.16.422";
+export const CHECKER_SINCE = "0.16.424";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *

package/dist/mode.js

@@ -0,0 +1,34 @@
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * NO PROJETO DELA, E LOCAL - e as duas metades são a promessa.
+ *
+ * NO PROJETO porque o sistema é COMPARTILHADO: um modo guardado na plataforma faria a escolha de
+ * uma pessoa barrar todas as outras que usam aquele design system.
+ *
+ * LOCAL - e não em `config.json`, que é versionado - porque o mesmo argumento vale um nível
+ * abaixo: um modo commitado barra o time inteiro porque uma pessoa ligou o dela. Este arquivo
+ * entra na lista de ignorados que a nossa pasta gerencia (ver `IGNORED` em `commands/add.ts`), e
+ * essa lista RECONCILIA, então quem já está conectado também o recebe.
+ */
+export const modePath = (root) => join(root, "_synthesisui", ".mode");
+/**
+ * O QUE ELA ESCOLHEU, OU NADA.
+ *
+ * QUALQUER COISA QUE NÃO SEJA UM DOS DOIS É "NADA", e isso é o lado seguro: um arquivo editado à
+ * mão, escrito por uma versão futura ou corrompido não é uma decisão de bloquear. Ler lixo como
+ * CONSUMIR seria a plataforma decidindo por ela a partir de algo que ela não escreveu.
+ */
+export async function readMode(root) {
+    const raw = await readFile(modePath(root), "utf8").catch(() => "");
+    const value = raw.trim().toLowerCase();
+    return value === "create" || value === "consume" ? value : null;
+}
+/** Escolher, ou desligar. `null` volta a não ter modo, em vez de virar o outro. */
+export async function writeMode(root, mode) {
+    if (mode === null) {
+        await rm(modePath(root), { force: true });
+        return;
+    }
+    await writeFile(modePath(root), `${mode}\n`, "utf8");
+}

package/package.json

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