synthesisui 0.16.335 → 0.16.337

package/dist/commands/import.js

@@ -5,7 +5,7 @@ import { applyAnatomyPatch, hasEdits, } from "../anatomy-patch.js";
 import { resolveAnatomy, resolveFlatParts, safePartName, } from "../anatomy-read.js";
 import { readCredentials, readToken, resolveRegistry, sameRegistry, } from "../config.js";
 import { declaredElsewhere } from "../declared-elsewhere.js";
-import { architectureRule, componentHome, describeArchitecture, describeChoice, detectArchitectures, homeLine, proposeNewHome, } from "../doctor/architecture.js";
+import { architectureGap, architectureRule, componentHome, describeArchitecture, describeChoice, describeGap, detectArchitectures, homeLine, proposeNewHome, } from "../doctor/architecture.js";
 import { findBrokenRefs } from "../doctor/broken-refs.js";
 import { nestingRules, propRules, readDefinitionProps, readNesting, readRuntime, } from "../doctor/call-sites.js";
 import { asCatalogueTable, describeFallback, fetchCatalogue, } from "../doctor/catalogue-fetch.js";
@@ -388,6 +388,21 @@ const MAX_GLOBAL_CLASSES = 300;
  * dois com folga e continua sendo um teto de verdade, alinhado com `DISTINCT_CAP` do ledger.
  */
 const SKIPPED_CAP = 4096;
+/**
+ * UM ARQUIVO QUE MOSTRA UM COMPONENTE NÃO É UM COMPONENTE - a mesma exclusão nos três lugares.
+ *
+ * Stories and tests compose components to SHOW them; counting those as the product's own
+ * composition is the same lie the colour census told before they were set aside.
+ *
+ * E ela vale igual para a CONTAGEM que a organização declara. Medido em 30/08 em
+ * `codelevel-monorepo/packages/ui`: 75 arquivos `.tsx`, dos quais 38 são `*.stories.tsx` e 37 são
+ * componente. Dizer "we read 75 component files" a quem tem 37 é metade do número inventada por
+ * nós - e a frase existe justamente para o caso em que o cliente vai conferir o número na mão.
+ *
+ * UMA constante, e não três literais: a terceira cópia já existia antes desta, e uma delas
+ * envelhecer sozinha significa dois denominadores diferentes para a mesma palavra na mesma saída.
+ */
+const SHOWS_A_COMPONENT = /(\.(spec|test|stories)\.[a-z]+$|__tests__\/|(^|\/)\.storybook\/)/;
 export async function takeCensus(root, opts) {
     /**
      * O RELATÓRIO SÓ SAI QUANDO ALGUÉM O PEDIU - `say` cala quando o chamador é uma RE-medição.
@@ -552,6 +567,8 @@ export async function takeCensus(root, opts) {
      * naming how the project is organised costs no second pass. See `architecture.ts`.
      */
     const dirs = new Map();
+    /** Uma entrada nova da árvore, com os três contadores em zero. */
+    const freshDir = () => ({ dirs: new Set(), files: 0, direct: 0 });
     /** Parent → child → the files that put one inside the other. */
     const nesting = new Map();
     /**
@@ -621,17 +638,37 @@ export async function takeCensus(root, opts) {
             continue;
         const rel = relative(root, file);
         progress.step(rel);
-        if (/\.(tsx|jsx|vue|svelte)$/i.test(rel)) {
+        /**
+         * A ORGANIZAÇÃO SÓ CONTA COMPONENTE - `SHOWS_A_COMPONENT`, a mesma exclusão de baixo.
+         *
+         * Este bloco roda onze linhas ANTES do filtro, e por isso contava story e teste como código
+         * do produto: 75 arquivos onde o cliente tem 37 (`codelevel-monorepo/packages/ui`, 30/08). O
+         * número que a organização declara é o que ele confere na mão, então ele conta o que ele
+         * conta quando confere.
+         */
+        if (/\.(tsx|jsx|vue|svelte)$/i.test(rel) && !SHOWS_A_COMPONENT.test(rel)) {
             const parts = rel.split("/");
             // Every ancestor learns the name of the child directly under it, which is all
             // the shape detector needs and is one pass rather than a tree walk.
             for (let i = 0; i < parts.length - 1; i++) {
                 const at = parts.slice(0, i).join("/");
-                const entry = dirs.get(at) ?? { dirs: new Set(), files: 0 };
+                const entry = dirs.get(at) ?? freshDir();
                 entry.dirs.add(parts[i]);
                 entry.files += 1;
                 dirs.set(at, entry);
             }
+            /**
+             * A PASTA-MÃE, CREDITADA PELO ARQUIVO QUE ELA SEGURA - ver `DirEntry.direct`.
+             *
+             * O laço acima nunca roda para um arquivo na RAIZ do escopo (`parts.length - 1 === 0`), e
+             * era isso que fazia um projeto de quatro componentes soltos - uma forma real de biblioteca
+             * pequena - não produzir entrada nenhuma e ficar em silêncio absoluto sobre a própria
+             * organização. Aqui a raiz é uma pasta como as outras.
+             */
+            const home = parts.slice(0, -1).join("/");
+            const entry = dirs.get(home) ?? freshDir();
+            entry.direct += 1;
+            dirs.set(home, entry);
         }
         sources.push({ file: rel, source: src });
         readSignalsInto(signals, importTally, rel, src);
@@ -639,7 +676,7 @@ export async function takeCensus(root, opts) {
         // Stories and tests compose components to SHOW them; counting those as the
         // product's own composition is the same lie the colour census told before
         // they were set aside.
-        if (!/(\.(spec|test|stories)\.[a-z]+$|__tests__\/|(^|\/)\.storybook\/)/.test(rel)) {
+        if (!SHOWS_A_COMPONENT.test(rel)) {
             scanComponentsInto(tally, rel, src, internal);
             /**
              * The other half: what this file EXPORTS, with the axes its types declare. A
@@ -1282,11 +1319,24 @@ export async function takeCensus(root, opts) {
         }
     }
     progress.done();
-    const architectures = detectArchitectures([...dirs.entries()].map(([path, v]) => ({
+    /** A ÁRVORE MEDIDA, uma vez - as três leituras abaixo saem todas dela. */
+    const dirEntries = [...dirs.entries()].map(([path, v]) => ({
         path: path || ".",
         dirs: [...v.dirs],
         files: v.files,
-    })));
+        direct: v.direct,
+    }));
+    const architectures = detectArchitectures(dirEntries);
+    /**
+     * A LACUNA, quando nada foi reconhecido - ver `architectureGap` (`INV-COB-08`). Nenhuma
+     * decisão aqui: este arquivo IMPRIME e GRAVA o que aquela camada decidiu.
+     */
+    const gap = architectureGap(dirEntries, architectures);
+    /**
+     * ONDE O PRÓXIMO COMPONENTE VAI - derivado do escopo que ele apontou, e por isso a
+     * pergunta sobrevive a não reconhecermos organização nenhuma.
+     */
+    const newHome = proposeNewHome(dirEntries, scopeLabel);
     const d = diagnose(reports);
     const allComposed = tallyToInventory(tally, 400);
     /**
@@ -1419,7 +1469,7 @@ export async function takeCensus(root, opts) {
             }
             edges.set(file, edgesIn(src));
             const rel = join(u.label, relative(u.path, file));
-            if (/(\.(spec|test|stories)\.[a-z]+$|__tests__\/|(^|\/)\.storybook\/)/.test(rel)) {
+            if (SHOWS_A_COMPONENT.test(rel)) {
                 continue;
             }
             usageSeen.add(rel);
@@ -2007,6 +2057,16 @@ export async function takeCensus(root, opts) {
             say(body(paint.faint(`  ${describeArchitecture(a)}`)));
         }
     }
+    else if (gap) {
+        /**
+         * A MESMA SEÇÃO, NO MESMO LUGAR DA SAÍDA - `INV-COB-08`. Uma leitura que rodou e não
+         * reconheceu nada tinha esta seção inteira desaparecendo, e a ausência lê como "não
+         * medimos nada aqui" em vez de "medimos, e a régua é nossa".
+         */
+        say("");
+        say(section("How this project is organised"));
+        say(body(describeGap(gap, scopeLabel)));
+    }
     if (skips.length > 0) {
         say("");
         say(body(describeGate(scoped.length, skips.length)));
@@ -2492,13 +2552,24 @@ export async function takeCensus(root, opts) {
                     line: homeLine(a),
                     rule: architectureRule(a, scopeLabel),
                 })),
-                ...(proposeNewHome(architectures, scopeLabel)
-                    ? {
-                        newComponentHome: proposeNewHome(architectures, scopeLabel),
-                    }
-                    : {}),
             }
             : {}),
+        /**
+         * A LEITURA QUE RODOU E NÃO RECONHECEU NADA - `INV-COB-08`, ver `architectureGap`.
+         *
+         * Só os DOIS números medidos. Sem nome de forma, sem regra e sem caminho: nada foi
+         * reconhecido, então qualquer um dos três seria adivinhação nossa gravada como fato dele.
+         */
+        ...(gap ? { architectureGap: gap } : {}),
+        /**
+         * FORA DO `if` DAS FORMAS, e é isso que mantém a pergunta viva - `INV-COB-08`.
+         *
+         * "Daqui em diante vai num lugar novo" é derivada do escopo que ele apontou e não depende
+         * de reconhecermos organização nenhuma. Presa dentro do bloco acima, ela sumia junto com o
+         * resto justamente para quem mais precisa dela: o projeto sobre o qual não temos nada a
+         * dizer é o único cujo agente não recebe regra de onde criar componente.
+         */
+        ...(newHome ? { newComponentHome: newHome } : {}),
         ...(skips.length > 0
             ? {
                 /**

package/dist/doctor/architecture.js

@@ -165,13 +165,26 @@ export function homeLine(a) {
  * ela a pergunta é sobre o passado.
  *
  * O caminho é DERIVADO, não inventado: fica dentro do escopo que a pessoa já apontou como
- * fonte de verdade, e usa `src/` só quando as formas medidas mostram que o escopo tem `src`.
+ * fonte de verdade, e usa `src/` só quando a árvore medida mostra que o escopo tem `src`.
  * Sem nome de sistema dentro dele de propósito - quem quer isso digita, e digitar um nome
  * é mais honesto do que a gente adivinhar a grafia dele.
  */
-export function proposeNewHome(found, scope) {
+export function proposeNewHome(
+/**
+ * A ÁRVORE MEDIDA, e não a lista do que foi reconhecido - a porta fechada.
+ *
+ * `hasSrc` era lido da lista de formas, e com ela VAZIA - que é exatamente o caso em que
+ * nenhuma organização conhecida apareceu - a resposta era sempre "não tem `src`": num
+ * projeto cujos 75 arquivos moram todos sob `src/`, a proposta mandava o cliente para uma
+ * pasta na raiz. Duas entradas (a árvore e as formas) podem discordar; uma não pode, e as
+ * formas saem da árvore aqui dentro.
+ */
+entries, scope) {
+    const found = detectArchitectures(entries);
     const base = scope ? scope.replace(/\/+$/, "") : "";
-    const hasSrc = found.some((a) => a.root === "src" || a.root.startsWith("src/"));
+    const hasSrc = entries.some((e) => e.path === "src" ||
+        e.path.startsWith("src/") ||
+        (isRoot(e.path) && e.dirs.includes("src")));
     const trunk = `${base ? `${base}/` : ""}${hasSrc ? "src/components" : "components"}`;
     const fresh = `${trunk}/{atoms, molecules, organisms}`;
     /** Se a proposta é o que já existe, ela não é uma pasta nova - e oferecê-la seria repetir a opção 1. */
@@ -233,3 +246,90 @@ export function describeChoice(found) {
     const list = options.map(say).join(", ");
     return `${options.length} shapes govern real code, and none of them is a mistake: ${list}.${notes.length > 0 ? ` Smaller corners, reported and not asked about: ${notes.map(say).join(", ")}.` : ""} Pick which one has PRIORITY - it becomes the rule every prompt reads, and the others stay true without deciding.`;
 }
+/** A raiz do escopo, que a caminhada escreve como `.` e o mapa guarda como "". */
+function isRoot(path) {
+    return path === "." || path === "";
+}
+/**
+ * A ORGANIZAÇÃO QUE NINGUÉM SOUBE NOMEAR - declarada, nunca calada (`INV-COB-08`).
+ *
+ * O QUE O CLIENTE GANHA: quando a leitura roda e nenhuma das organizações conhecidas
+ * aparece, ele continua recebendo uma resposta - quantos arquivos de componente foram
+ * medidos, e em quantas pastas eles estão - com a frase dizendo que o limite é a nossa
+ * régua e não o projeto dele. Sem isto a seção inteira sobre organização SOME da saída, e
+ * silêncio é indistinguível de "não medimos nada aqui": ele fica sem saber que a régua
+ * rodou, sem o número que ela mediu, e sem a chance de dizer onde o próximo componente vai.
+ *
+ * MEDIÇÃO de 30/08 - a população e a régua de enumeração de escopo estão escritas UMA vez, em
+ * `contracts/camada-4-cobertura.md` (`INV-COB-08`), e não são recopiadas aqui: 6 de 43 escopos
+ * com componentes (14%) não casam nenhuma organização conhecida, e o maior deles tem 37
+ * arquivos. No banco de produção, na mesma data, há 1 sistema com censo de import guardado, e
+ * ele é um dos mudos - 1 de 1. Foto daquelas populações naquele dia, nunca invariante.
+ *
+ * O QUE ESTE BLOCO NÃO FAZ, de propósito: reconhecer uma organização nova. Uma sexta forma é
+ * outra entrega. Aqui a ausência de reconhecimento vira DECLARAÇÃO, nunca um palpite.
+ */
+/**
+ * ABAIXO DISTO NÃO HÁ ORGANIZAÇÃO A DECLARAR - há conteúdo.
+ *
+ * MEDIÇÃO de 30/08 - população e régua de enumeração de escopo em
+ * `contracts/camada-4-cobertura.md` (`INV-COB-08`): dos 6 escopos mudos, 4 têm um ou dois
+ * arquivos de componente ao todo. Um ou dois arquivos não organizam nada, e dizer "não sei
+ * nomear a sua organização" sobre eles é ruído com cara de lacuna. Os 2 que sobram são os que a
+ * frase existe para alcançar - 37 arquivos em 37 pastas, e 7 arquivos em 1 pasta. O 3 é lido
+ * dessa foto, e não é regra do produto.
+ *
+ * O piso é ancorado por LITERAIS no spec (2 cala, 3 fala) e não por esta constante: um teste
+ * escrito como `GAP_MIN_FILES - 1` acompanha a constante para onde ela for, e com ela em zero o
+ * produto imprimiria "We read 0 component files in 0 folders" - o zero pelado da lei 14 - com a
+ * suíte inteira verde.
+ */
+export const GAP_MIN_FILES = 3;
+/**
+ * A LEITURA QUE RODOU E NÃO RECONHECEU NADA - o estado `unknown` desta leitura.
+ *
+ * Devolve `null` quando há forma reconhecida (aí quem fala é `describeChoice`) e quando o
+ * escopo é pequeno demais para ter organização (`GAP_MIN_FILES`).
+ */
+export function architectureGap(entries, found) {
+    if (found.length > 0)
+        return null;
+    /**
+     * SOMAR `direct`, e nunca `files`: a caminhada credita cada arquivo a TODOS os ancestrais,
+     * então somar `files` conta o mesmo arquivo uma vez por nível. `direct` é o arquivo na pasta
+     * onde ele está, uma vez só - a mesma conta que o `find` acima faz na máquina dele.
+     */
+    let files = 0;
+    let folders = 0;
+    for (const e of entries) {
+        if (e.direct <= 0)
+            continue;
+        files += e.direct;
+        folders += 1;
+    }
+    if (files < GAP_MIN_FILES)
+        return null;
+    return { files, folders };
+}
+/**
+ * A FRASE, no tom das outras desta camada: o número medido, o motivo, e nenhuma acusação.
+ *
+ * A ordem é a da dúvida de quem lê - o que medimos, de quem é o limite, e o que isso custa
+ * a ele hoje. A segunda parte não é gentileza: sem ela a frase lê como um defeito do
+ * repositório dele, e o defeito é da régua.
+ */
+export function describeGap(g, 
+/**
+ * ONDE MEDIMOS, quando a leitura foi apontada para uma parte do repositório.
+ *
+ * "here" não resolve para nada na cabeça de quem rodou `--scope packages/ui` da raiz de um
+ * monorepo, e num import de dois lugares a mesma seção sai duas vezes falando de pastas
+ * diferentes. Sem rótulo a redação continua a mesma: uma leitura da raiz não tem outro
+ * lugar a que se referir.
+ */
+where) {
+    const files = `${g.files} component file${g.files === 1 ? "" : "s"}`;
+    const folders = `${g.folders} folder${g.folders === 1 ? "" : "s"}`;
+    const at = where ? `under \`${where}\`` : "here";
+    return `We read ${files} in ${folders} ${at}, and none of the ways of organising code this version can name fits them. That does not mean your project has no structure; it means ours does not have a name for yours yet. Nothing about where code lives was written into your rules, so an agent reading your \`CLAUDE.md\` guesses where a new component goes until you tell it.`;
+}

package/dist/doctor/transcribe.js

@@ -2220,12 +2220,47 @@ function ownReturn(source, declAt) {
     }
     return -1;
 }
+/**
+ * A RAIZ POLIMÓRFICA RESOLVIDA PARA O ELEMENTO QUE ELA REALMENTE É (T21, dono, 26/08).
+ *
+ * O QUE O CLIENTE VIA: o blueprint do botão dele anunciando a raiz como `Tag` - o nome de uma
+ * variável local que só existe dentro do arquivo dele, apresentado como se fosse um elemento. O
+ * código é `const Tag = (as ?? "button") as ElementType`, e a raiz é um `<button>`.
+ *
+ * A LEI 13 pede a ORIGEM, e um identificador local não tem nenhuma: não há especificador de import
+ * atrás de `Tag`. Onde o próprio arquivo declara o DEFAULT, ele é a origem - e lê-lo é derivar, não
+ * supor.
+ *
+ * SÓ O QUE É DERIVÁVEL, e a fronteira é o literal. Medido nos dois repositórios vivos em 30/08:
+ *
+ *     4 declarações polimórficas no `codelevel`, 0 no `frontend-hub`
+ *     Button.tsx  `const Tag = (as ?? "button") as ElementType`   -> button
+ *     Card.tsx    `const Tag = (as ?? "div") as ElementType`      -> div
+ *     Typography  `const Tag: ElementType = as ?? MAPA[variante]` -> fica `Tag`
+ *     SkillNode   `const Icon = icon ?? MAPA[estado]`             -> fica `Icon`
+ *
+ * As duas últimas definem a regra: o default vem de um mapa indexado em runtime, então não existe
+ * UM elemento para resolver. Escolher um seria inventar a raiz do componente dele - e a raiz decide
+ * a marcação que a gente devolve. Sem literal, o nome fica como está.
+ *
+ * (A primeira contagem deste dia disse TRÊS: a régua exigia o literal na mesma linha e não via o
+ * `SkillNode`. Remedida com a régua larga, que é a que responde "quantos a forma alcança".)
+ */
+const POLYMORPHIC_DEFAULT = /(?:const|let)\s+NAME\s*(?::[^=]*)?=\s*\(?\s*[A-Za-z_$][\w$]*\s*(?:\?\?|\|\|)\s*["']([a-z][a-z0-9-]*)["']/;
 export function rootTag(source, name) {
     const ret = returnAt(source, name);
     if (ret === -1)
         return null;
     const m = /<([A-Za-z][A-Za-z0-9.]*)/.exec(source.slice(ret));
-    return m ? m[1] : null;
+    if (!m)
+        return null;
+    const tag = m[1];
+    // Só um identificador local pode ser uma raiz polimórfica: uma tag HTML já é o elemento, e um
+    // nome com ponto (`Tabs.Root`) é membro de um objeto importado, não uma variável com default.
+    if (!/^[A-Z][A-Za-z0-9]*$/.test(tag))
+        return tag;
+    const declared = new RegExp(POLYMORPHIC_DEFAULT.source.replace("NAME", tag)).exec(source);
+    return declared ? declared[1] : tag;
 }
 export function rootClasses(source, name) {
     const ret = returnAt(source, name);

package/dist/install-marks.js

@@ -361,13 +361,35 @@ export const CHECKER_SINCE = "0.16.308";
  * componentes que devolvem um Fragment recuperam as classes que hoje caem no vazio, e 386 de 386
  * looks legados leem exatamente como liam.
  *
+ * 0.16.334 -> 0.16.336 em 30/08 (T21-CLI): `rootTag` passou a resolver a raiz polimórfica para o
+ * elemento que ela é - `const Tag = (as ?? "button")` grava `button`, e não mais o nome da variável
+ * local. Um censo já gravado carrega `rootTag: "Tag"` e não há como derivar o elemento a partir
+ * dele: o default mora no CÓDIGO, que só a remedição lê. Por isso a marca sobe.
+ *
+ * Medido nos dois repositórios vivos: 4 declarações da forma no `codelevel` (2 resolvem para um
+ * elemento, 2 têm default vindo de um mapa em runtime e ficam com o nome), 0 no `frontend-hub`.
+ *
  * 0.16.328 -> 0.16.329 em 28/08: `rootClasses` passou a ler só o `className` do PRÓPRIO elemento.
  * Antes ele ancorava no primeiro `className=` do texto da tag de abertura, então a classe de um JSX
  * escrito dentro de uma prop virava classe da raiz - e o `className` da raiz, quando vinha depois,
  * nunca era alcançado. Medido: 1134 componentes, 77 mudaram, e a receita que o cliente recebe muda
  * com eles. Uma medição anterior não produz o conserto, então a marca sobe.
  */
-export const READER_SINCE = "0.16.334";
+/**
+ * 0.16.336 -> 0.16.337 em 30/08 (INV-COB-08): a contagem de arquivos por organização deixou de
+ * incluir story, spec e teste. Um censo já gravado carrega o número inflado - `atomic@src/lib/SignalUI`
+ * dizia 69 arquivos onde há 38 - e esse número viaja para o CLAUDE.md do cliente como a EVIDÊNCIA da
+ * regra (`architectureRule().evidence`, "holding N component files"). Não há como corrigi-lo a partir
+ * do censo: saber quais daqueles arquivos eram story exige reler o disco, e só a remedição lê. Por
+ * isso a marca sobe.
+ *
+ * MEDIÇÃO de 30/08 - população e régua de enumeração de escopo em
+ * `contracts/camada-4-cobertura.md` (`INV-COB-08`): `frontend-hub/packages/ui` sai de 69 para 38
+ * (mesma forma, mesmo lugar); `codelevel/packages/ui` sai de 75 para 37. O ranking não mudou em
+ * nenhum dos 43 escopos medidos, então ninguém recebe uma organização DIFERENTE - só o número
+ * honesto.
+ */
+export const READER_SINCE = "0.16.337";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/merge-census.js

@@ -119,6 +119,32 @@ export function mergeCensus(list) {
     let brokenRefs = first.brokenRefs ?? undefined;
     let conventions = first.conventions ?? undefined;
     let architectures = first.architectures ?? undefined;
+    /**
+     * A LACUNA DE ORGANIZAÇÃO, SOMADA - `INV-COB-08`, ver `architectureGap` em `import.ts`.
+     *
+     * A declaração de qualquer escopo SOBREVIVE à fusão. Ela diz "medimos aqui e não soubemos
+     * nomear"; deixá-la de fora porque o outro escopo foi reconhecido devolve o silêncio que a
+     * invariante existe para eliminar, um passo adiante - e o cliente que rodou com dois escopos
+     * é justamente quem tem mais lugar onde a resposta pode sumir.
+     *
+     * SOMADOS, e não o primeiro que aparece, porque os dois são CONTAGENS e contagem é aditiva:
+     * o total descreve exatamente as partes que ficaram sem nome, e nenhum arquivo contado aqui
+     * pertence a um escopo reconhecido. É o oposto do caso da cobertura logo abaixo, onde somar
+     * percentuais produziria um número que não descreve medição nenhuma.
+     */
+    let gapFiles = first.architectureGap
+        ?.files;
+    let gapFolders = first.architectureGap
+        ?.folders;
+    /**
+     * ONDE O PRÓXIMO COMPONENTE VAI - o PRIMEIRO escopo vence, a mesma regra de `scope`.
+     *
+     * É um caminho, não uma contagem: dois caminhos não somam, e escolher o do escopo seguinte
+     * mandaria o agente para um lugar fora do escopo que o censo declara como o dele.
+     */
+    const newComponentHome = list
+        .map((c) => c.newComponentHome)
+        .find((h) => typeof h === "string" && h.length > 0);
     let components = first.components ?? undefined;
     let defined = first.defined ?? undefined;
     const stack = [...(first.project.stack ?? [])];
@@ -177,6 +203,11 @@ export function mergeCensus(list) {
         brokenRefs = concat(brokenRefs, c.brokenRefs);
         conventions = concat(conventions, c.conventions);
         architectures = concat(architectures, c.architectures);
+        const gap = c.architectureGap;
+        if (gap) {
+            gapFiles = (gapFiles ?? 0) + (gap.files ?? 0);
+            gapFolders = (gapFolders ?? 0) + (gap.folders ?? 0);
+        }
         components = concat(components, c.components);
         defined = concat(defined, c.defined);
         for (const s of c.project.stack ?? [])
@@ -260,6 +291,10 @@ export function mergeCensus(list) {
         out.conventions = conventions;
     if (architectures && architectures.length > 0)
         out.architectures = architectures;
+    if (gapFiles !== undefined && gapFolders !== undefined)
+        out.architectureGap = { files: gapFiles, folders: gapFolders };
+    if (newComponentHome)
+        out.newComponentHome = newComponentHome;
     if (components && components.length > 0)
         out.components = components;
     if (defined && defined.length > 0)

package/package.json

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