synthesisui 0.16.428 → 0.16.430

package/dist/claude-md.js

@@ -184,14 +184,29 @@ best reasoning you produce.`;
  * A checagem é LOCAL e grátis: o censo grava qual CLI o mediu (`ledger.cli`) e o servidor MCP É o CLI,
  * então comparar as duas versões é aritmética em disco. Nada aqui telefona para casa - é a mesma
  * decisão que mantém o hook instalado.
+ *
+ * O TEXTO DEIXOU DE DIZER "IT COSTS NOTHING" em 16/09, e a correção é de fidelidade, não de estilo.
+ * Medido: `remeasure` não recusa por versão - ele mede e ENVIA em toda chamada, e a comparação de
+ * versões só imprime um aviso. Então a frase antiga descrevia um comportamento que o código nunca
+ * teve, e a cota diária do plano grátis transformou essa imprecisão em consequência: o agente
+ * gastaria o teto da pessoa seguindo uma instrução nossa, escrita no repositório dela, dizendo que
+ * não custava nada.
+ *
+ * O que o bloco diz agora é o que a régua do plano diz: PERGUNTAR é livre, ENVIAR tem teto - e
+ * quando o teto chega, o agente repassa a frase em vez de tentar de novo.
  */
 const REFRESH = `
 
 **Call \`refresh_system\` once before you write UI here, or before you describe what
-this system holds.** Not "if you think the measurement is stale" - always, once per
-session. It costs nothing when nothing changed: the tool holds both versions and
-refuses politely when there is nothing to refresh, so calling it is cheaper than
-deciding whether to.
+this system holds** - once per session, not once per file, and never in a loop.
+
+It is an UPDATE and not a question: it re-measures this repository and sends it. On
+the free plan that counts against the updates the plan covers per day, and when the
+day's updates are used up the tool says so and nothing is lost - the measurement
+stays on disk, and every question you ask about this system keeps being answered.
+Asking is always free; it is sending that has a ceiling. If it says the ceiling was
+reached, say that to the person and carry on with what you already know - do not
+retry it.
 
 It re-measures this repo with the current reader, reuses what was already written
 about this app, and sends it - a newer reader sees styles the old one could not, and

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 RELATÓRIO QUE O `inspect` ESCREVE - a leitura inteira com forma, para ele abrir no navegador.
+     * Mesma natureza do censo: é a MEDIÇÃO, reescrita por inteiro a cada rodada, então versioná-la é
+     * conflito toda vez e ainda poria um HTML de meio megabyte no diff de quem só rodou o comando.
+     */
+    "report.html",
     /**
      * 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
@@ -78,7 +84,12 @@ export async function ensureGovernanceHome(projectRoot) {
     await mkdir(join(projectRoot, "_synthesisui"), { recursive: true });
     await writeGovernanceIgnore(projectRoot);
 }
-async function writeGovernanceIgnore(projectRoot) {
+/**
+ * EXPORTADO desde 18/09 porque o `inspect` passou a escrever um arquivo na pasta: o relatório. Um
+ * comando de primeiro contato que deixa um HTML de 30 KB aparecendo no `git status` de quem só quis
+ * olhar cobra da pessoa uma limpeza que ela não pediu - e a pasta já é declarada gerenciada aqui.
+ */
+export async function writeGovernanceIgnore(projectRoot) {
     const path = join(projectRoot, "_synthesisui", ".gitignore");
     const existing = await readFile(path, "utf8").catch(() => null);
     /**

package/dist/commands/import.js

@@ -55,12 +55,14 @@ import { body, bodyWrapped, paint, section } from "../output.js";
 import { consumersOf, outsideScope, } from "../outside-scope.js";
 import { phase, startProgress } from "../progress.js";
 import { repoStateOf } from "../repo-state.js";
+import { relatorioHtml, secoesDe } from "../report-html.js";
 import { runtimeDeclaredVars, runtimeDeclaredVarsIn } from "../runtime-vars.js";
 import { detectStack, resolveDeps, stackVersions } from "../stack.js";
+import { desligarCaptura, ligarCaptura } from "../transcript.js";
 import { wiredSlugs, wiringWarning } from "../wired-slugs.js";
 import { harvestWorkspaceCss } from "../workspace-css.js";
 import { placeInWorkspace } from "../workspace-place.js";
-import { add } from "./add.js";
+import { add, writeGovernanceIgnore } from "./add.js";
 import { walk, walkAll } from "./doctor.js";
 /**
  * UMA PÁGINA DELE, como ele a montou - ver `Census.pages`.
@@ -3720,6 +3722,145 @@ export function defaultScheme(declared) {
     return dark > light ? "dark" : "light";
 }
 /** On a dry run there is nobody to ask, so say what was measured. */
+/**
+ * A TELA DO `inspect`, E O ARQUIVO QUE CARREGA O RESTO (dono, 18/09).
+ *
+ * O QUE O CLIENTE GANHA: ele decide sem rolar. Ficam na tela os quatro blocos que MUDAM o que ele
+ * vai fazer em seguida - quanto foi lido, se o root tem mais de um app, o que não resolve, e onde
+ * está a leitura inteira. Medido na saída dele em 18/09: 250 linhas, 94 delas a mesma frase sobre
+ * nome de parte. Nada se perde: o texto inteiro está no relatório, escrito pela MESMA esteira.
+ *
+ * A FRASE DO CONTRATO MUDA, E É A ÚNICA COISA QUE MUDA: era "nothing was written, and nothing was
+ * sent". Passa a dizer a verdade - nada enviado, um arquivo escrito, e aqui está ele. Uma frase que
+ * promete silêncio enquanto o comando escreve um arquivo é pior que o arquivo.
+ */
+async function mostrarInspecao(c, root, transcrito) {
+    const secoes = secoesDe(transcrito);
+    const valores = c.values?.classes;
+    const decisoes = valores ? valores.seen - valores.structure : 0;
+    const pct = valores && decisoes > 0
+        ? Math.round((valores.interpreted / decisoes) * 100)
+        : null;
+    const lidos = c.coverage?.read ?? 0;
+    const total = c.coverage?.components ?? 0;
+    const arquivo = join(root, "_synthesisui", "report.html");
+    const html = () => relatorioHtml({
+        cabecalho: {
+            repo: c.measured?.repo ?? basename(root),
+            medidoEm: c.measured?.at ?? "",
+            cli: c.ledger?.cli ?? "",
+        },
+        destaques: [
+            {
+                numero: `${lidos} of ${total}`,
+                rotulo: "components came out with a blueprint",
+            },
+            ...(pct === null
+                ? []
+                : [
+                    {
+                        numero: `${pct}%`,
+                        rotulo: `of ${decisoes} style decisions carry your vocabulary`,
+                    },
+                ]),
+            {
+                numero: String(c.brokenRefs?.length ?? 0),
+                rotulo: "references that resolve to nothing",
+            },
+        ],
+        secoes,
+    });
+    console.log(section("What came out of your files"));
+    console.log(body(`${paint.strong(`${lidos} of ${total}`)} components came out with a blueprint${pct === null
+        ? ""
+        : `, and ${paint.strong(`${pct}%`)} of your ${decisoes} style decisions carry your own vocabulary`}.`));
+    /**
+     * OS DOIS BLOCOS QUE MUDAM O QUE ELE FAZ EM SEGUIDA, e eles saem do transcrito em vez de serem
+     * reescritos: a régua que os produziu é a mesma, então a tela nunca diverge do relatório.
+     */
+    for (const titulo of DECIDEM) {
+        const achada = secoes.find((s) => s.titulo === titulo);
+        if (!achada)
+            continue;
+        console.log(section(titulo));
+        for (const linha of achada.linhas)
+            console.log(linha);
+    }
+    /**
+     * O ARQUIVO SÓ NASCE SE ELE PEDIR (dono, 18/09) - e é isto que mantém `INV-INSPECT-01` de pé.
+     *
+     * A promessa que faz alguém rodar este comando sem medo é que nada acontece: ele lê, mostra, e
+     * o repositório continua exatamente como estava. Escrever o relatório por conta própria
+     * quebraria isso para TODO mundo, inclusive para quem só queria olhar - e num primeiro contato
+     * essa é a confiança inteira. Perguntando, a escrita deixa de ser nossa e passa a ser dele.
+     *
+     * SEM TERMINAL, NÃO PERGUNTA E NÃO ESCREVE: um `inspect` dentro de um pipe, de um CI ou de um
+     * agente não tem quem responda, e um default que escreve seria a mesma quebra por outra porta.
+     * É a mesma guarda que `askName` já usa.
+     */
+    console.log(section("The whole reading, in one file"));
+    console.log(body(`${secoes.length} sections did not print here - every value, every fragment, every part.`));
+    console.log(body(paint.faint("A single self-contained page in your project. Nothing is sent either way.")));
+    if (!(await quer(`    write the full report? [Y/n]: `))) {
+        console.log("");
+        console.log(body("Nothing was written, and nothing was sent."));
+        console.log("");
+        console.log(body("To let your agent ask before it invents:"));
+        console.log(body(`    ${paint.strong("npx synthesisui@latest connect")}`));
+        console.log("");
+        return;
+    }
+    await mkdir(dirname(arquivo), { recursive: true });
+    /**
+     * A PASTA SE DECLARA GERENCIADA ANTES DE RECEBER O ARQUIVO: sem isto, o HTML apareceria no
+     * `git status` de quem acabou de pedir um relatório, e não um arquivo versionado.
+     */
+    await writeGovernanceIgnore(root).catch(() => null);
+    await writeFile(arquivo, html(), "utf8");
+    console.log("");
+    console.log(body(`    ${paint.strong(relative(root, arquivo))}`));
+    console.log(body(`    ${paint.dim(`file://${arquivo}`)}`));
+    console.log("");
+    console.log(body("To let your agent ask before it invents:"));
+    console.log(body(`    ${paint.strong("npx synthesisui@latest connect")}`));
+    console.log("");
+}
+/**
+ * A PERGUNTA DE UMA TECLA, e o silêncio de quem não tem terminal.
+ *
+ * Fora de um terminal a resposta é NÃO, sempre: ninguém está lá para responder, e assumir o sim
+ * escreveria no repositório de um CI que só queria ler. Enter é sim porque a pessoa acabou de ler
+ * a oferta na linha acima - exigir uma letra para receber o que a tela ofereceu é atrito sem
+ * proteção nenhuma.
+ */
+async function quer(pergunta) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log("");
+        const resposta = (await rl.question(pergunta)).trim().toLowerCase();
+        return resposta === "" || resposta === "y" || resposta === "yes";
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * AS SEÇÕES QUE CONTINUAM NA TELA, e o critério é um só: elas mudam o comando seguinte.
+ *
+ * Um root com três apps mede a média de três paletas, o que é diagnóstico e não sistema - e a saída
+ * já traz o `--scope`/`--usage` exato. Um `var()` que não resolve não pinta cor nenhuma no
+ * navegador dele. As outras quinze seções descrevem; estas duas pedem uma decisão.
+ */
+const DECIDEM = [
+    "This root holds several projects",
+    "These resolve to nothing",
+];
 function sayReach(c) {
     const reach = ladderReach(c.declared);
     console.log("");
@@ -4332,6 +4473,16 @@ export async function runImport(opts) {
         if (!opts.inspect)
             phase(1, 3, "Measuring the repository");
         console.log(section("Reading your project"));
+        /**
+         * A PARTIR DAQUI O `inspect` GUARDA EM VEZ DE IMPRIMIR - ver `transcript.ts`.
+         *
+         * As dezessete seções continuam sendo escritas exatamente como sempre foram; o que muda é o
+         * destino. Elas vão para o relatório, e o terminal fica com os quatro blocos que uma pessoa
+         * usa para DECIDIR. Medido na saída do `codelevel-monorepo` em 18/09: 250 linhas, das quais 94
+         * eram a mesma frase sobre nome de parte - 40% do relatório num detalhe sem ação possível.
+         */
+        if (opts.inspect)
+            ligarCaptura();
         /**
          * UMA MEDIÇÃO POR ESCOPO, E DEPOIS A FUSÃO.
          *
@@ -4448,13 +4599,8 @@ export async function runImport(opts) {
      */
     if (opts.inspect) {
         sayReach(census);
-        console.log("");
-        console.log(section("Your agent cannot ask any of this yet"));
-        console.log(body("Nothing was written, and nothing was sent."));
-        console.log("");
-        console.log(body("To let it ask before it invents:"));
-        console.log(body(`    ${paint.strong("npx synthesisui@latest connect")}`));
-        console.log("");
+        const transcrito = desligarCaptura();
+        await mostrarInspecao(census, root, transcrito);
         return;
     }
     const out = opts.census ?? join(root, "_synthesisui", "census.json");

package/dist/commands/mcp.js

@@ -1790,13 +1790,27 @@ cli) {
             const token = await readToken();
             if (!token)
                 return fromContract("Not signed in, so nothing could be sent. A person has to run `synthesisui login` once in the terminal - it opens a browser, and I cannot complete it for them.");
-            const { out } = await capturing(() => remeasure({
+            const { out, value: refused } = await capturing(() => remeasure({
                 root,
                 base: resolveRegistry(),
                 token,
                 slug,
                 cli: VERSION,
             }));
+            /**
+             * O TETO DO PLANO CHEGA AO AGENTE COMO RESPOSTA, e não como silêncio.
+             *
+             * Esta ferramenta é uma ATUALIZAÇÃO, não uma consulta: ela re-mede o repositório e envia.
+             * Então ela conta contra o teto diário do plano grátis, e quando o teto é atingido o envio
+             * não acontece. Sem esta linha o agente receberia a saída capturada sem a recusa dentro
+             * dela - `remeasure` devolve o motivo em vez de imprimi-lo, para o `sync` poder dizê-lo por
+             * último no terminal - e concluiria que a medição subiu.
+             *
+             * A frase vem do servidor inteira, com o endereço junto, porque aqui não há terminal para
+             * quebrar linha: quem lê é o agente, e ele precisa do endereço para repassar à pessoa.
+             */
+            if (refused)
+                return fromContract(`${refused.message}${refused.url ? `\n\n  ${refused.url}` : ""}\n\nNothing was lost: the measurement is on disk and every question you ask about this system keeps being answered. Say this to the person instead of retrying.`);
             /**
              * E A DEFASAGEM DO HOOK, EM TRÊS LINHAS - não num parágrafo.
              *

package/dist/commands/sync.js

@@ -168,8 +168,20 @@ export async function sync(opts) {
      * Então: a plataforma devolve o que já foi decidido (o escopo e a leitura), o CLI mede com o leitor
      * ATUAL, funde a leitura no censo fresco, AVISA o que seria reescrito, e envia. Sem entrevista.
      */
-    if (!opts.recordOnly)
-        await remeasure({
+    /**
+     * A RECUSA É GUARDADA PARA O FIM, e essa é a diferença entre informar e enganar.
+     *
+     * O comando continua depois da medição: ele fecha pedidos, manda o registro de checagens e
+     * termina imprimindo "N checks sent". Uma recusa dita no meio disso rola para cima, e a ÚLTIMA
+     * linha da tela anuncia sucesso para uma rodada em que o design system dela não foi atualizado.
+     *
+     * O registro de checagens SOBE mesmo assim, e isso é deliberado: é outra rota, é o que alimenta
+     * "você está na v2 e existe a v4", e não é o envio pesado que a cota governa. Dizer as duas
+     * coisas na ordem em que aconteceram é mais honesto que abortar tudo.
+     */
+    const refused = opts.recordOnly
+        ? null
+        : await remeasure({
             root,
             base,
             token,
@@ -206,6 +218,7 @@ export async function sync(opts) {
     if (emptyLedger && !repo && forms.length === 0) {
         console.log(section("Sync"));
         console.log(body("Nothing recorded yet. The record fills as the hook checks writes and doctor runs."));
+        sayRefused(refused);
         return;
     }
     const res = await fetch(`${base}/api/ledger`, {
@@ -308,21 +321,29 @@ export async function sync(opts) {
      * nada, que é o caso normal.
      */
     await reportWhatIsLeft(root);
+    sayRefused(refused);
 }
 /**
- * MEDE DE NOVO, AVISA, E ENVIA - o corpo do `sync` que faz um leitor novo chegar num sistema.
+ * O QUE NÃO FOI ENVIADO, DITO POR ÚLTIMO - e o "por último" é o desenho, não um detalhe.
  *
- * A ordem é a lei aqui, e cada passo existe por um caso real:
+ * A pessoa lê a última seção da tela e é ela que decide o que ela conclui do comando. O registro
+ * de checagens subiu de verdade, então a linha "N checks sent" é verdadeira e fica; o que não
+ * pode é ela ser a ÚLTIMA coisa numa rodada em que o design system não foi atualizado.
  *
- *   1. a plataforma devolve o ESCOPO e a LEITURA já gravados. Sem isto, o `sync` teria que
- *      perguntar de novo o que já foi decidido, e um agente reescreveria 261 anatomias.
- *   2. mede com o leitor ATUAL - é o único passo que precisa estar nesta máquina, porque o fonte
- *      dele não sai daqui.
- *   3. funde a leitura gravada no censo fresco. A anatomia é do agente; a medição é nossa.
- *   4. AVISA antes de enviar o que seria reescrito, e pergunta. Avisar depois de escrever não é
- *      avisar.
- *   5. envia para a rota que atualiza o RASCUNHO pelo slug - nada publicado se move.
+ * NÃO SE LÊ COMO ERRO: a frase vem do servidor, que é quem conhece o teto, a contagem e a hora em
+ * que a próxima libera. E o endereço vai em linha própria, indentado, como toda ação que o
+ * terminal oferece - prosa quebra em 66 colunas e um endereço no meio de um parágrafo não se
+ * distingue do parágrafo.
  */
+function sayRefused(refused) {
+    if (!refused)
+        return;
+    console.log("");
+    console.log(section("Your system was not updated"));
+    console.log(body(refused.message));
+    if (refused.url)
+        console.log(body(`    ${paint.blue(refused.url)}`));
+}
 export async function remeasure(args) {
     const { root, base, token, slug } = args;
     const head = await fetch(`${base}/api/registry/ds/${slug}/reading`, {
@@ -333,7 +354,7 @@ export async function remeasure(args) {
         console.log(body(head
             ? `The registry answered ${head.status} for this system's reading, so nothing was re-measured. The record below still travels.`
             : "Could not reach the registry, so nothing was re-measured. The record below still travels."));
-        return;
+        return null;
     }
     const stored = (await head.json());
     /**
@@ -343,7 +364,7 @@ export async function remeasure(args) {
     if (!stored.hasCensus) {
         console.log(section("Sync"));
         console.log(body(`"${slug}" did not come from an import, so there is no measurement to refresh. Import it first: npx synthesisui import`));
-        return;
+        return null;
     }
     /**
      * A DISTÂNCIA ATÉ O CLI PUBLICADO, dita onde ele já está.
@@ -461,7 +482,7 @@ export async function remeasure(args) {
         : null;
     if (!census) {
         console.log(body("The measurement failed, so nothing was sent."));
-        return;
+        return null;
     }
     /** A LEITURA GRAVADA ENTRA NO CENSO FRESCO - ver a rota `reading`. */
     if (stored.reading)
@@ -564,7 +585,7 @@ export async function remeasure(args) {
             .join(" · "))));
         if (!(await askToOverwrite())) {
             console.log(body("Nothing was sent. Your draft is untouched."));
-            return;
+            return null;
         }
     }
     /**
@@ -634,11 +655,33 @@ export async function remeasure(args) {
                 : {}),
         }),
     }).catch(() => null);
+    /**
+     * O TETO DE ATUALIZAÇÕES DO PLANO GRÁTIS - e ele NÃO se lê como um erro, porque não é um.
+     *
+     * O QUE ELA VIVE: o envio parou porque o plano dela atualiza um número de vezes por dia, e a
+     * frase diz quantas já foram, que a medição continua no disco dela, que as perguntas do agente
+     * seguem respondendo, e a HORA em que a próxima libera. O endereço do plano vai em linha
+     * própria, indentado, como toda ação que o terminal oferece - prosa quebra em 66 colunas e um
+     * endereço enterrado no meio de um parágrafo não se distingue do parágrafo.
+     *
+     * A FRASE VEM DO SERVIDOR e não é escrita aqui: é ele quem conhece o teto, a contagem e o
+     * horário. Uma segunda redação deste texto no CLI é o dia em que alguém muda a cota e o
+     * terminal continua anunciando a antiga - e o terminal é onde a pessoa está parada.
+     */
+    if (res?.status === 429) {
+        const door = (await res.json().catch(() => null));
+        return {
+            kind: "quota",
+            message: door?.message ??
+                "Your free plan has reached its updates for today, so your design system was not updated.",
+            url: door?.url ?? null,
+        };
+    }
     if (!res?.ok) {
         console.log(body(res
             ? `The registry answered ${res.status}. Nothing was written.`
             : "Could not reach the registry. Nothing was written."));
-        return;
+        return null;
     }
     const out = (await res.json());
     console.log("");
@@ -842,6 +885,8 @@ export async function remeasure(args) {
         console.log(body(paint.faint(`${work.measured} declared piece${work.measured === 1 ? "" : "s"} of work re-checked against this measurement`)));
     if (!args.full)
         console.log(body(paint.faint("everything the reader saw:  npx synthesisui sync --full")));
+    /** Chegou até aqui: a medição foi enviada e escrita. Nada a recusar. */
+    return null;
 }
 /**
  * Pergunta uma vez, e só num terminal de verdade.

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.424";
+export const MATERIALISER_SINCE = "0.16.429";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/report-html.js

@@ -0,0 +1,205 @@
+import { semCor } from "./transcript.js";
+/**
+ * O QUE O TERMINAL DIRIA, LIDO DE VOLTA COMO DOCUMENTO.
+ *
+ * A régua `── Título ──────` é a única marca estrutural que a saída tem, e ela é desenhada num
+ * lugar só (`section`), então é ela que separa os capítulos. Tudo antes da primeira régua é ruído
+ * de progresso e não entra: o documento começa no primeiro capítulo, não no meio do carregamento.
+ */
+export function secoesDe(linhas) {
+    const secoes = [];
+    for (const bruta of linhas) {
+        for (const linha of semCor(bruta).split("\n")) {
+            const cabeca = /^──\s(.+?)\s─*$/.exec(linha.trimEnd());
+            if (cabeca) {
+                secoes.push({ titulo: cabeca[1].trim(), linhas: [] });
+                continue;
+            }
+            if (secoes.length === 0)
+                continue;
+            secoes[secoes.length - 1].linhas.push(linha.replace(/\s+$/, ""));
+        }
+    }
+    /** Capítulo que não disse nada não vira capítulo - uma régua sozinha não é conteúdo. */
+    return secoes
+        .map((s) => ({ ...s, linhas: aparar(s.linhas) }))
+        .filter((s) => s.linhas.length > 0);
+}
+/** Tira as linhas em branco das pontas, e nunca as do meio - lá elas são respiro. */
+function aparar(linhas) {
+    let i = 0;
+    let f = linhas.length;
+    while (i < f && linhas[i].trim() === "")
+        i += 1;
+    while (f > i && linhas[f - 1].trim() === "")
+        f -= 1;
+    return linhas.slice(i, f);
+}
+function escapar(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+export function relatorioHtml(input) {
+    const { cabecalho, destaques, secoes } = input;
+    const quando = legivel(cabecalho.medidoEm);
+    const indice = secoes
+        .map((s, i) => `<li><a href="#s${i}">${escapar(s.titulo)}</a></li>`)
+        .join("\n        ");
+    const corpo = secoes
+        .map((s, i) => `      <section id="s${i}">
+        <h2>${escapar(s.titulo)}</h2>
+        <pre>${escapar(s.linhas.join("\n"))}</pre>
+      </section>`)
+        .join("\n");
+    const numeros = destaques
+        .map((d) => `        <div class="stat">
+          <strong>${escapar(d.numero)}</strong>
+          <span>${escapar(d.rotulo)}</span>
+        </div>`)
+        .join("\n");
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapar(cabecalho.repo)} - read by SynthesisUI</title>
+<style>
+${estilo()}
+</style>
+</head>
+<body>
+  <header>
+    <p class="kicker">Read by SynthesisUI</p>
+    <h1>${escapar(cabecalho.repo)}</h1>
+    <p class="meta">Read ${escapar(quando)} by CLI ${escapar(cabecalho.cli)} &middot; nothing left this machine</p>
+  </header>
+
+  <div class="wrap">
+    <div class="stats">
+${numeros}
+    </div>
+
+    <nav>
+      <p class="kicker">What is in here</p>
+      <ol>
+        ${indice}
+      </ol>
+    </nav>
+
+    <main>
+${corpo}
+    </main>
+
+    <footer>
+      <p>This file lives in your project and was never sent anywhere. Re-run the command to refresh it.</p>
+    </footer>
+  </div>
+</body>
+</html>
+`;
+}
+/** A data em palavras. Data ilegível some da frase em vez de imprimir `Invalid Date`. */
+function legivel(iso) {
+    if (!iso || Number.isNaN(Date.parse(iso)))
+        return "just now";
+    return new Date(iso).toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+    });
+}
+/**
+ * A FOLHA, E ELA É INTEIRA DAQUI: nenhuma família remota, nenhum reset de terceiro. As famílias são
+ * as genéricas do sistema de quem abrir, porque baixar uma fonte para desenhar um relatório sobre o
+ * repositório de alguém contradiz o comando que não manda nada para lugar nenhum.
+ *
+ * E ela imprime: `@media print` existe porque o navegador já exporta PDF, e um relatório que sai
+ * torto no papel obriga a construir um gerador de PDF para resolver o que uma regra resolve.
+ */
+function estilo() {
+    return `:root {
+  color-scheme: light dark;
+  --ink: #16161a;
+  --ink-soft: #55555f;
+  --line: #e4e4e9;
+  --paper: #ffffff;
+  --canvas: #f6f6f8;
+  --accent: #b4530a;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --ink: #edecea;
+    --ink-soft: #a0a0aa;
+    --line: #2a2a31;
+    --paper: #17171b;
+    --canvas: #0f0f12;
+    --accent: #e9a13b;
+  }
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  background: var(--canvas);
+  color: var(--ink);
+  font: 15px/1.6 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif;
+}
+header {
+  padding: 56px 24px 40px;
+  border-bottom: 1px solid var(--line);
+  background: var(--paper);
+}
+.wrap, header > * { max-width: 900px; margin-inline: auto; }
+.wrap { padding: 0 24px 72px; }
+.kicker {
+  margin: 0;
+  font: 600 11px/1.4 ui-monospace, SFMono-Regular, Menlo, monospace;
+  letter-spacing: 0.16em;
+  text-transform: uppercase;
+  color: var(--accent);
+}
+h1 { margin: 12px 0 8px; font-size: 34px; line-height: 1.15; letter-spacing: -0.02em; }
+.meta { margin: 0; color: var(--ink-soft); font-size: 14px; }
+.stats {
+  display: grid;
+  gap: 12px;
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  margin: -28px 0 40px;
+}
+.stat {
+  background: var(--paper);
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  padding: 18px 20px;
+}
+.stat strong { display: block; font-size: 26px; letter-spacing: -0.02em; }
+.stat span { display: block; margin-top: 4px; color: var(--ink-soft); font-size: 13px; }
+nav { margin-bottom: 40px; }
+nav ol { margin: 10px 0 0; padding-left: 20px; color: var(--ink-soft); }
+nav li { margin: 3px 0; }
+nav a { color: inherit; }
+nav a:hover { color: var(--accent); }
+section {
+  background: var(--paper);
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  padding: 22px 24px;
+  margin-bottom: 16px;
+}
+h2 { margin: 0 0 12px; font-size: 17px; letter-spacing: -0.01em; }
+pre {
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+  font: 12.5px/1.65 ui-monospace, SFMono-Regular, Menlo, monospace;
+  color: var(--ink-soft);
+}
+footer { margin-top: 40px; color: var(--ink-soft); font-size: 13px; }
+@media print {
+  body { background: #fff; }
+  .stat, section { break-inside: avoid; border-color: #ddd; }
+  nav { display: none; }
+}`;
+}

package/dist/transcript.js

@@ -0,0 +1,50 @@
+/**
+ * O QUE O TERMINAL TERIA IMPRIMIDO, GUARDADO EM VEZ DE MOSTRADO.
+ *
+ * O QUE O CLIENTE GANHA: a saída do `inspect` volta a caber numa tela, e nada do que ela dizia se
+ * perde - o texto inteiro vai para o relatório que ele abre quando quiser.
+ *
+ * POR QUE AQUI E NÃO EM CADA IMPRESSOR: são dezessete seções escritas em dezessete lugares, e a
+ * leitura delas é a mesma coisa que a esteira já sabe dizer. Reescrevê-las num gerador de HTML
+ * criaria duas redações da mesma medição - e no dia em que uma fosse editada, o relatório passaria
+ * a afirmar algo que o terminal não afirma mais. Capturando, existe UMA fonte: o que a esteira diz.
+ *
+ * ELE É DELIBERADAMENTE BURRO: liga, guarda, desliga. Sem filtro, sem formatação e sem saber o que
+ * é seção - quem entende do assunto é quem transforma isto em documento.
+ */
+let guardadas = null;
+let originalLog = null;
+/**
+ * A REDE DE SEGURANÇA, e ela existe por um motivo específico: uma medição que lança no meio
+ * deixaria o `console.log` desviado pelo resto do processo, e a pessoa veria o comando morrer sem
+ * uma linha de explicação. O terminal volta ao normal mesmo quando ninguém se lembra de desligar.
+ */
+process.once("exit", () => {
+    if (originalLog)
+        console.log = originalLog;
+});
+/** Começa a guardar em vez de imprimir. Chamar duas vezes não empilha - a segunda é um no-op. */
+export function ligarCaptura() {
+    if (guardadas)
+        return;
+    guardadas = [];
+    originalLog = console.log;
+    console.log = (...args) => {
+        guardadas?.push(args.map((a) => (typeof a === "string" ? a : String(a))).join(" "));
+    };
+}
+/** Devolve o terminal a quem é dele, e entrega o que foi guardado. */
+export function desligarCaptura() {
+    const linhas = guardadas ?? [];
+    if (originalLog)
+        console.log = originalLog;
+    guardadas = null;
+    originalLog = null;
+    return linhas;
+}
+/** O caractere de escape ANSI, montado por código para não viajar cru no arquivo. */
+const ESC = String.fromCharCode(27);
+/** Tira a cor: o que vai para um arquivo não carrega sequência de escape de terminal. */
+export function semCor(line) {
+    return line.split(new RegExp(`${ESC}\\[[0-9;]*m`)).join("");
+}

package/package.json

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