synthesisui 0.16.500 → 0.16.502

package/dist/claude-md.js

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { loadRoleRules, rolesContract } from "./role-rules.js";
 import { dirname, join } from "node:path";
@@ -5,6 +6,13 @@ import { hasHook } from "./agent-wiring.js";
 import { declaredReference } from "./group-role.js";
 import { recallAvailable } from "./memory/availability.js";
 import { readResponsiveForm, responsiveLine } from "./responsive-form.js";
+/**
+ * A LEITURA - o caminho do sistema desde a fase 1 (18/10). Escrita uma vez e usada nos dois contratos: o de quem já tem
+ * sistema sem `rules.json` e o de quem chegou pela porta e ainda não tem sistema nenhum (fase 2).
+ */
+const READ_THE_PAGE = "**Once the first screen is done, offer to read it - once.** If their next message does not take the offer up, do not offer it again; they can still ask. When the person asks you to read their page - or right after the creation of the first screen ends (with impeccable, once it has written `DESIGN.md`; never while it still asks for another round) - run `npx synthesisui read` with the dev server up, tell them in a few lines the system it found, then ask the questions in `_synthesisui/reading.json` ONE AT A TIME with your question tool (the first option is the default). Save their answers as `{ \"<question id>\": <option index> }` and run `npx synthesisui read --confirm <that file>`: their answers become the roles and breaks this project keeps.";
+/** A frase do revisor depois da criação - ver o comentário em `renderRegion`, junto dos papéis. */
+const REVIEWER_AFTER_CREATION = "\n\n**How a change closes here.** The visual world is decided - the roles and breaks above. From here on SynthesisUI's check closes a change (`check_file`, and the end-of-turn check). Impeccable's reviewer is for creating: spawn `impeccable-finish-reviewer` or run `impeccable detect` only when the person asks for a new visual direction or a large new surface with its own look - never as the routine close of a change, and never its degraded self-review in its place.";
 const START = "<!-- synthesisui:start -->";
 const END = "<!-- synthesisui:end -->";
 /** Reads the installed DSs from the .lock files in _synthesisui/ds/<slug>/. */
@@ -337,9 +345,10 @@ async function renderRegion(projectRoot, installed) {
             "This project has the synthesisui agent set up and **no design system yet** - so there is",
             "no token vocabulary to follow, and nothing here to obey.",
             "",
-            "To turn this repository into one, run `/sui-import-ds` and I will read what is",
-            "already in the code: the colours, the type, the shapes and the components. Nothing",
-            "is invented, and nothing is copied out.",
+            READ_THE_PAGE,
+            "",
+            "A system kept somewhere else - a published one, or a repository's own - comes in with",
+            "`/sui-import-ds` instead: it reads what is already in the code. Nothing is invented.",
             "",
             "The `synthesisui` MCP server is registered, so ASK it instead of guessing - it",
             "answers what exists and what does not. This block fills itself in once a system is",
@@ -469,12 +478,18 @@ written now** - read the code before you edit it, never a remembered signature.`
      * livres passa pelo `landing` antes de qualquer linha - ele lista as seções do catálogo e devolve o prompt da pilha, com
      * as decisões tomadas. Sem servidor também: o `landing` fala com o registro direto.
      */
+    /**
+     * O REVISOR DA CAMADA DE ESTÉTICA SÓ NA CRIAÇÃO - decisão dele, 18/10 15:23 ("só na criação"). Antes da confirmação o
+     * impeccable segue as próprias instruções, revisor incluído: o mundo ainda está sendo criado. Com o sistema confirmado,
+     * fecha a mudança a nossa checagem. Pela instrução, nunca apagando o agente dele - compor, não forkar (15:25). A medida
+     * que motivou: no fluxo com o revisor em todo turno, 52 de 103 min e metade dos tokens (estudo de 18/10, seção 12).
+     */
     /** Os papéis e as quebras que a página dele já decidiu - ver `role-rules.ts` (18/10). Só existe com `rules.json`. */
     const roleRules = await loadRoleRules(projectRoot).catch(() => null);
     const rolesLine = roleRules
-        ? rolesContract(roleRules)
+        ? rolesContract(roleRules) + (existsSync(join(projectRoot, ".claude", "skills", "impeccable")) ? REVIEWER_AFTER_CREATION : "")
         : /** Sem rules.json ainda: o agente oferece a leitura (jornada "a leitura no agente", E03, 18/10). */
-            "\n\n**Once the first screen exists, offer to read it.** When the person asks you to read their page - or right after you build the first screen - run `npx synthesisui read` with the dev server up, tell them in a few lines the system it found, then ask the questions in `_synthesisui/reading.json` ONE AT A TIME with your question tool (the first option is the default). Save their answers as `{ \"<question id>\": <option index> }` and run `npx synthesisui read --confirm <that file>`: their answers become the roles and breaks this project keeps.";
+            `\n\n${READ_THE_PAGE}`;
     const landingLine = '\n\n**A landing asked in free words:** run `npx synthesisui@latest landing <slug> "<their words>"` first, and follow it.';
     const preferencesLine = recall.available
         ? `

package/dist/commands/add.js

@@ -81,6 +81,8 @@ const IGNORED = [
      * da mesma versão, em branches separadas, darem conflito numa linha só.
      */
     ".fetched-at.json",
+    /** A oferta da leitura, feita uma vez neste clone - ver `offerTheReading` (fase 2, 18/10). */
+    ".read-offered",
 ];
 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/connect.js

@@ -316,7 +316,10 @@ export async function connect(opts) {
      * A PERGUNTA SÓ EXISTE ONDE HÁ ALGUÉM PARA RESPONDER. Em `--ci`, num pipe ou dentro de um agente,
      * `ask` vai `null` e a pasta decide - e a linha DIZ que foi ela, porque silêncio nunca é escolha.
      */
-    const interactive = !opts.ci && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+    const interactive = !opts.ci &&
+        opts.interactive !== false &&
+        Boolean(process.stdin.isTTY) &&
+        Boolean(process.stdout.isTTY);
     const chosen = await chooseAgents({
         root,
         flag: opts.agents,
@@ -471,7 +474,7 @@ export async function connect(opts) {
      */
     if (want.hook && wired.hook !== "skipped") {
         const before = await readAutoSync(root).catch(() => null);
-        const now = before ?? (await askToSendAtTurnEnd());
+        const now = before ?? (opts.interactive === false ? null : await askToSendAtTurnEnd());
         if (before === null && now !== null)
             await writeAutoSync(root, now);
         row(before === null, now === true
@@ -784,7 +787,8 @@ export async function connect(opts) {
         }
     }
     /** A mesma versão que a fiação do editor recebe - os dois pinam no mesmo número. */
-    await offerShellHook(opts.shell === true, opts.version);
+    if (opts.interactive !== false)
+        await offerShellHook(opts.shell === true, opts.version);
     /**
      * O REINÍCIO SÓ QUANDO ELE É NECESSÁRIO - e pedi-lo sempre é o que fez o dono achar que reiniciar
      * o editor fazia parte do fluxo (07/08).

package/dist/commands/hook.js

@@ -1,6 +1,6 @@
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { ourSpellingLines } from "../our-spelling.js";
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { readAutoSync, startSync } from "../auto-sync.js";
 import { changedSince } from "../changed-files.js";
@@ -317,7 +317,7 @@ async function report(root, filePath, mode) {
     const ours = d.tokenUses;
     /** Os papéis e as quebras que a página dele já decidiu - ver `role-rules.ts` (18/10). */
     const roleRules = await loadRoleRules(root).catch(() => null);
-    const roles = roleRules ? await onlyOnce(root, rel, checkRoles(rel, src, roleRules)) : [];
+    const roles = roleRules ? await onlyOnce(root, rel, checkRoles(rel, src, roleRules, root)) : [];
     // Every check leaves one line in the ledger - INCLUDING the clean ones,
     // because a fix is itself a write, so the clean re-check of a file that was
     // just flagged is the evidence the agent read the report and acted. Without
@@ -743,7 +743,11 @@ async function endOfTurn(root, input) {
         await startSync(root).catch(() => false);
     const out = (frame) => process.stdout.write(`${JSON.stringify(frame)}\n`);
     if (input.stop_hook_active) {
-        out(pass());
+        /** A única exceção à passagem calada: a oferta que ainda não chegou à resposta final - ver `offerTheReading`. */
+        const again = existsSync(join(root, "_synthesisui", READ_OFFERED_FILE))
+            ? await offerTheReading(root, [], input.transcript_path).catch(() => null)
+            : null;
+        out(again ? { decision: "block", reason: again } : pass());
         return;
     }
     const clock = await turnClockOf(root);
@@ -763,10 +767,166 @@ async function endOfTurn(root, input) {
     const grown = await takeGrowthNote(root).catch(() => null);
     if (grown)
         said.push(grown);
+    const offer = await offerTheReading(root, changed, input.transcript_path, clock).catch(() => null);
     await moveTurnClock(root);
-    out(said.length === 0
+    out(said.length === 0 && !offer
         ? pass()
-        : { decision: "block", reason: [...said, CLOSE_THE_TURN].join("\n\n") });
+        : { decision: "block", reason: [...said, offer ?? CLOSE_THE_TURN].join("\n\n") });
+}
+/** O arquivo que lembra que a oferta já foi feita neste clone - ignorado pelo git (ver `add.ts`). */
+export const READ_OFFERED_FILE = ".read-offered";
+/** Uma tela: o que o agente escreve quando faz interface. CSS conta - a primeira tela do impeccable mexe no globals. */
+const SCREEN = /\.(tsx|jsx|vue|svelte|astro|html|css|scss)$/;
+/**
+ * A LEITURA OFERECIDA SOZINHA - E03 da jornada "um instalador, uma porta" (fase 2, 18/10). O dono: *"o agente oferece a
+ * leitura sozinho depois da primeira tela"*. A linha do contrato já dizia "depois da primeira tela, ofereça" - e o agente
+ * só oferecia quando a pessoa pedia (medido na fase 1). O fim do turno é o único momento que vê o turno inteiro, então é
+ * ele quem pede.
+ *
+ * QUANDO A CRIAÇÃO ACABOU, NÃO NO MEIO DELA - decisão dele em 19/10, depois de seis rodadas reais. O impeccable tem um
+ * fim: a última coisa que ele escreve é o `DESIGN.md` (1-2 min antes do fim nas 3 rodadas que terminaram, porta-1, 3 e 6;
+ * ausente nas 3 em que a criação ainda perguntava "outra rodada?", porta-2, 4 e 5). Oferecer antes disso punha duas
+ * perguntas na mesma resposta, e a do impeccable ganhava. Então: com o impeccable no projeto, o sinal é o `DESIGN.md`
+ * escrito; sem ele, a primeira tela.
+ *
+ * FEITA É QUANDO ESTÁ NA RESPOSTA FINAL. Enquanto a última resposta do agente não oferece a leitura, o fim do turno pede de
+ * novo - três vezes no máximo. Depois de oferecida, ela vale até a PESSOA falar: na porta-6 a oferta saiu certa e os
+ * subagentes do impeccable acordaram o agente mais 4 vezes, e a resposta final ficou sem ela. Enquanto a pessoa não falou
+ * e a última resposta não tem a oferta, ela volta no fim (cinco renovações no máximo, a trava contra laço). Quando a
+ * pessoa fala, acabou: a recusa não vira insistência.
+ *
+ * SÓ NA PORTA: projeto sem sistema nenhum. Quem já tem um (do catálogo, importado, ou o da leitura com `rules.json`)
+ * escolheu o caminho dele (achado na suíte, 18/10: o fecho do turno de um sistema instalado passou a terminar na oferta).
+ * Sem o registro da conversa não há como ler a resposta - e aí se pede uma vez só.
+ */
+const MAX_OFFERS = 3;
+const MAX_RENEWALS = 5;
+export async function offerTheReading(root, changed, transcript, since = 0) {
+    const ds = join(root, "_synthesisui", "ds");
+    if (existsSync(ds) && readdirSync(ds).some((d) => statSync(join(ds, d)).isDirectory()))
+        return null;
+    const marker = join(root, "_synthesisui", READ_OFFERED_FILE);
+    const save = (s) => writeFile(marker, `${JSON.stringify(s)}\n`);
+    if (!existsSync(marker)) {
+        if (!(await creationDone(root, changed, since)))
+            return null;
+        await save({ count: 1, at: Date.now() });
+        return OFFER;
+    }
+    let state = null;
+    try {
+        state = JSON.parse(await readFile(marker, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!state || !transcript)
+        return null;
+    if (state.delivered) {
+        if ((state.renewals ?? 0) >= MAX_RENEWALS)
+            return null;
+        if (await lastReplyOffers(transcript))
+            return null;
+        if (typeof state.deliveredAt !== "number" || (await personSpokeAfter(transcript, state.deliveredAt))) {
+            await save({ ...state, renewals: MAX_RENEWALS });
+            return null;
+        }
+        await save({ ...state, renewals: (state.renewals ?? 0) + 1 });
+        return `You were woken up again after offering it, so it is no longer at the end of your reply. ${OFFER}`;
+    }
+    if ((state.count ?? MAX_OFFERS) >= MAX_OFFERS)
+        return null;
+    if (await lastReplyOffers(transcript)) {
+        await save({ ...state, delivered: true, deliveredAt: Date.now() });
+        return null;
+    }
+    const count = (state.count ?? 0) + 1;
+    await save({ ...state, count, at: Date.now() });
+    return `Your last reply did not offer it. ${OFFER}`;
+}
+/**
+ * A CRIAÇÃO ACABOU NESTE TURNO? Com o impeccable (a skill que o instalador DELE escreve), o `DESIGN.md` na raiz, e escrito
+ * ou acompanhado de uma tela neste turno - um `DESIGN.md` antigo, sem tela nova, não é fim de criação nenhuma. Sem o
+ * impeccable, a primeira tela.
+ */
+async function creationDone(root, changed, since) {
+    const screen = changed.some((c) => SCREEN.test(c.rel));
+    if (!existsSync(join(root, ".claude", "skills", "impeccable")))
+        return screen;
+    const design = await stat(join(root, "DESIGN.md")).catch(() => null);
+    if (!design?.isFile())
+        return false;
+    return screen || design.mtimeMs >= since;
+}
+const OFFER = "The creation of this project's first screen is done, and it has no system yet. Answer anything above in a line or two, then the summary of what this turn did - and END your reply with ONE sentence offering to read the page and turn what it already decided into their design system (about a minute, a few questions). That sentence is the LAST line, after any question of your own. If they say yes, follow the contract: `npx synthesisui read` with the dev server up. Offer it ONCE: if their next message does not take it up, that is a no - never offer it again in later turns.";
+/**
+ * A ÚLTIMA RESPOSTA DO AGENTE OFERECE A LEITURA? A última entrada `assistant` com texto, no registro. Nas quatro rodadas
+ * em que ele ofereceu, a frase tinha as duas coisas: ler a página (ou o site) e o sistema - "Want me to read the page and
+ * turn what it's already decided into your design system?". Na porta-7 (19/10) a oferta veio pelo nome do comando, sem
+ * "page": "I can run `npx synthesisui read` and ask you a few questions to lock in the design system".
+ */
+export async function lastReplyOffers(transcript) {
+    const raw = await readFile(transcript, "utf8").catch(() => null);
+    if (raw === null)
+        return false;
+    for (const line of raw.split("\n").reverse()) {
+        if (!/"type":\s*"assistant"/.test(line))
+            continue;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const c = e.message?.content;
+        const text = Array.isArray(c)
+            ? c.filter((x) => x?.type === "text").map((x) => x.text ?? "").join(" ")
+            : typeof c === "string" ? c : "";
+        if (!text.trim())
+            continue;
+        if (!/\bsystem\b/i.test(text))
+            return false;
+        return /\bread\b[^.?!]{0,60}\b(page|site|landing)\b/i.test(text) || /synthesisui read\b/i.test(text);
+    }
+    return false;
+}
+/**
+ * A PESSOA FALOU DEPOIS DE `at`? No registro, a fala dela é uma entrada `user` que não é meta, não é resultado de
+ * ferramenta, não é o retorno de um gancho e não é o aviso de um subagente - os três últimos também chegam como `user`.
+ * Sem o registro, conta como falou: na dúvida, não se insiste.
+ */
+export async function personSpokeAfter(transcript, at) {
+    const raw = await readFile(transcript, "utf8").catch(() => null);
+    if (raw === null)
+        return true;
+    for (const line of raw.split("\n").reverse()) {
+        if (!/"type":\s*"user"/.test(line))
+            continue;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (e.type !== "user" || e.isMeta || !e.timestamp)
+            continue;
+        if (!(Date.parse(e.timestamp) > at))
+            return false;
+        const c = e.message?.content;
+        const text = typeof c === "string"
+            ? c
+            : Array.isArray(c) && !c.some((x) => x?.type === "tool_result")
+                ? c.map((x) => x?.text ?? "").join(" ")
+                : null;
+        if (text === null)
+            continue;
+        if (/^\s*(<task-notification>|<command-|<system-reminder>|Stop hook feedback)/.test(text))
+            continue;
+        return true;
+    }
+    return false;
 }
 /**
  * A ÚLTIMA MENSAGEM É O RESUMO, NÃO O RODAPÉ - bateria ampliada, item 19 (29/09). Este bloqueio faz o agente responder

package/dist/commands/init.js

@@ -2,10 +2,12 @@ import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { DEFAULT_CONFIG, resolveRegistry, writeProjectConfig, } from "../config.js";
 import { readProjectTheme, writeBesideTheirs, writeNewProjectRoot, writeNewProjectTheme, } from "../new-project-theme.js";
+import { openTheDoor } from "../door.js";
 import { body, section, snippet } from "../output.js";
 import { fetchDesignSystem } from "../registry.js";
 import { resolveDeps, stylesFor, tailwindMajor } from "../stack.js";
 import { formMix, measuredStyle } from "../styles-flavour.js";
+import { desligarCaptura, ligarCaptura } from "../transcript.js";
 import { add } from "./add.js";
 const whereOf = (answer) => answer === "file" || answer === "1"
     ? "file"
@@ -57,6 +59,14 @@ export async function init(opts) {
      */
     if (opts.ds)
         await fetchDesignSystem(resolveRegistry(opts.registry), opts.ds);
+    /**
+     * SEM `--ds`, O `init` É A PORTA (fase 2, 18/10) - ver `door.ts`. O que ele imprimia sobre o config continua sendo
+     * calculado igual, só que guardado: a porta fecha com um resumo de cinco linhas, e o detalhe do config é o que menos
+     * importa para quem acabou de chegar.
+     */
+    const door = !opts.ds;
+    if (door)
+        ligarCaptura();
     const target = opts.target === "general" ? "general" : "next";
     const config = {
         target,
@@ -270,11 +280,14 @@ export async function init(opts) {
         console.log(body("first clean file and goes quiet after that."));
         return;
     }
-    console.log("");
-    console.log("Next steps:");
-    console.log("  • synthesisui connect                 wire your agent to the system");
-    console.log("  • synthesisui add <slug>              bring a design system in");
-    console.log("  • synthesisui template <slug> <name>  materialize a full page");
+    await openTheDoor({
+        root,
+        version: opts.cli ?? "latest",
+        ...(opts.registry ? { registry: opts.registry } : {}),
+        ...(opts.pkg ? { pkg: opts.pkg } : {}),
+        ...(opts.aesthetic ? { aesthetic: opts.aesthetic } : {}),
+        configLines: desligarCaptura(),
+    });
 }
 /**
  * O QUE O `init` ACABOU DE DECLARAR VAI PARA O `.lock` (jornada "o pedido livre sai mastigado", 15/10).

package/dist/commands/read.js

@@ -1,4 +1,6 @@
 import { execFileSync } from "node:child_process";
+import { desligarCaptura, ligarCaptura } from "../transcript.js";
+import { adopt } from "./adopt.js";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
@@ -6,7 +8,7 @@ import { join, relative } from "node:path";
 import { classify, pixelRatio } from "../reading/classify.js";
 import { PAGE_SCRIPT } from "../reading/page-script.js";
 import { decodePng } from "../reading/png.js";
-import { pxOf } from "../role-rules.js";
+import { globalClassOf, globalStyles, moduleClassName, pxOf } from "../role-rules.js";
 import { agentsToMaintain } from "../agents-chosen.js";
 import { syncClaudeMd } from "../claude-md.js";
 import { projectRootFrom } from "./hook.js";
@@ -112,12 +114,46 @@ function sources(root) {
     return out;
 }
 /** Onde o texto mora no código: o componente (React) -> o arquivo que o declara -> a linha da classe; senão, pela classe. */
+/**
+ * A CLASSE DE UM CSS MODULE NO DOM - `page-module___8aEwW__h2` (o Turbopack: arquivo, hash, nome local). Achado na rodada
+ * real da porta (18/10): sem isto, a página que o impeccable escreveu com `styles.h2` saía com 5 papéis lidos e 0
+ * gravados. A extensão vem do import que o código escreve.
+ */
+function moduleOf(cls, files) {
+    /* a do próprio elemento primeiro; sem ela, a do título e a do pai (a capa da porta-2: `<span>` sem classe dentro de
+       `<p className={styles.batch}>`, com o tamanho em `.batch span`) */
+    for (const tok of cls.split(" | ").flatMap((part) => part.split(/\s+/))) {
+        const m = tok.match(/^([A-Za-z0-9-]+?)-module__.+?__([A-Za-z0-9_-]+)$/);
+        if (!m)
+            continue;
+        const stem = m[1];
+        const local = m[2];
+        const imp = new RegExp(`["'][^"']*\\b${stem}\\.module\\.(s?css)["']`);
+        const ext = files.map((f) => readFileSync(f, "utf8").match(imp)?.[1]).find(Boolean) ?? "css";
+        return { name: moduleClassName(`${stem}.module.${ext}`, local), local };
+    }
+    return null;
+}
+let stylesOf = null;
 function homeOf(root, files, t) {
-    const cls = sizeClassOf(t.cls);
+    const sized = sizeClassOf(t.cls);
+    /* a classe global (o juízo dele, 19/10): `className="section-title"` com o tamanho no globals.css - a do elemento
+       primeiro, depois a do pai (o `<h3>` sem classe dentro de `.route`, medido em `.route h3`) */
+    if (!sized && stylesOf?.root !== root)
+        stylesOf = { root, styles: globalStyles(root) };
+    const glob = sized || moduleOf(t.cls, files) ? null
+        : globalClassOf(t.cls.split(" | ").flatMap((part) => part.split(/\s+/)), stylesOf?.styles ?? []);
+    const mod = sized ? null : (moduleOf(t.cls, files) ?? (glob ? { name: glob.name, local: glob.local } : null));
+    const cls = sized ?? mod?.name ?? null;
     const lineOf = (f) => {
         if (!cls)
             return null;
-        const i = readFileSync(f, "utf8").split("\n").findIndex((l) => l.includes(cls));
+        const lines = readFileSync(f, "utf8").split("\n");
+        const i = mod
+            ? lines.findIndex((l) => glob
+                ? new RegExp(`className=[^>]*?(?<![\\w-])${mod.local.replace(/-/g, "\\-")}(?![\\w-])`).test(l)
+                : new RegExp(`\\b\\w+(?:\\.${mod.local}\\b|\\[["']${mod.local}["']\\])`).test(l))
+            : lines.findIndex((l) => l.includes(cls));
         return i >= 0 ? i + 1 : null;
     };
     if (t.comp) {
@@ -126,7 +162,7 @@ function homeOf(root, files, t) {
         if (f)
             return { file: relative(root, f), line: lineOf(f), cls, via: "component", component: t.comp };
     }
-    if (cls) {
+    if (cls && !mod) {
         const f = files.find((x) => readFileSync(x, "utf8").includes(cls));
         if (f)
             return { file: relative(root, f), line: lineOf(f), cls, via: "class", component: t.comp };
@@ -194,9 +230,21 @@ export async function confirm(opts) {
     const answers = opts.answers ? JSON.parse(readFileSync(opts.answers, "utf8")) : {};
     const pick = (id) => answers[id] ?? 0;
     const dsDir = join(root, "_synthesisui", "ds");
-    const slug = existsSync(dsDir) ? readdirSync(dsDir).find((d) => statSync(join(dsDir, d)).isDirectory()) : undefined;
+    const firstSystem = () => existsSync(dsDir) ? readdirSync(dsDir).find((d) => statSync(join(dsDir, d)).isDirectory()) : undefined;
+    /* O SISTEMA NASCE AQUI quando o projeto chegou pela porta (fase 2, 18/10): o `init` não adota, porque num projeto vazio
+       os únicos tokens são os de exemplo do create-next-app. Agora a página já decidiu - os tokens que ela tem são os dela. */
+    if (!firstSystem()) {
+        ligarCaptura();
+        try {
+            await adopt({ dir: root, write: true });
+        }
+        finally {
+            desligarCaptura();
+        }
+    }
+    const slug = firstSystem();
     if (!slug) {
-        say("This project has no adopted system yet - run `synthesisui adopt --write` first.");
+        say("No tokens found in this project's CSS, so there is no system to write the answers into - check that the page's stylesheet declares them in :root or @theme.");
         process.exitCode = 1;
         return;
     }
@@ -222,6 +270,10 @@ export async function confirm(opts) {
     writeFileSync(join(dsDir, slug, "rules.json"), `${JSON.stringify(rules, null, 2)}\n`);
     const contract = await syncClaudeMd(root, await agentsToMaintain(root));
     say(`Your system: ${roles.length} roles and ${breaks.length} breaks, written to _synthesisui/ds/${slug}/rules.json.`);
+    /* NUNCA CALADO (o juízo dele, 19/10): um papel lido sem a classe que o identifica no código fica fora - e isso se diz */
+    const unplaced = R.roles.filter((r) => !r.home?.cls);
+    if (unplaced.length > 0)
+        say(`Left out: ${unplaced.map((r) => `${r.role.split(" ")[0]} ${r.px}px`).join(", ")} - the page shows ${unplaced.length === 1 ? "it" : "them"}, but no class in the code says where ${unplaced.length === 1 ? "it is" : "they are"}, so the check could not hold ${unplaced.length === 1 ? "it" : "them"}.`);
     say(contract ? "The contract your agent reads now lists them - every heading is checked against its role at the end of each turn." : "Run `synthesisui connect` so your agent reads and checks it.");
 }
 export async function read(opts) {

package/dist/door.js

@@ -0,0 +1,176 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { connect } from "./commands/connect.js";
+import { MCP_TOOL_COUNT } from "./commands/mcp.js";
+import { body, paint, section, snippet } from "./output.js";
+import { SKILLS } from "./skills.js";
+import { desligarCaptura, ligarCaptura } from "./transcript.js";
+/**
+ * A CAMADA DE ESTÉTICA PADRÃO, na versão que a régua do conjunto provou (18/10: corte, linhas A-C, relógios). O impeccable
+ * muda rápido; subir este número pede a régua de novo (D10 do mapa), não só o publish dele.
+ */
+export const IMPECCABLE_VERSION = "4.6.0";
+/** O impeccable que já está no projeto, pela skill que o instalador DELE escreve - nunca por um arquivo nosso. */
+export function impeccableIn(root) {
+    const skill = join(root, ".claude", "skills", "impeccable", "SKILL.md");
+    if (!existsSync(skill))
+        return null;
+    try {
+        const head = readFileSync(skill, "utf8").slice(0, 4000);
+        return /^version:\s*(\S+)/m.exec(head)?.[1] ?? "?";
+    }
+    catch {
+        return "?";
+    }
+}
+/** Uma pergunta, o sim como padrão - e só num terminal de verdade. */
+async function askAesthetic() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return null;
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`  Add the aesthetic layer - impeccable ${IMPECCABLE_VERSION}, by its own installer? It creates the first look; SynthesisUI keeps every screen after it consistent. [Y/n] `);
+        return !/^n/i.test(answer.trim());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * COMPOR, NUNCA FORKAR (decisão dele, 18/10 15:25): o SynthesisUI é o ecossistema e o impeccable é uma camada. Quem
+ * instala é o instalador DELE, chamado por nós; nenhum arquivo dele é escrito, copiado ou apagado aqui. Já instalado,
+ * fica como está.
+ */
+async function aestheticLayer(root, wanted) {
+    const found = impeccableIn(root);
+    if (found)
+        return { kind: "found", version: found };
+    if (wanted === "none")
+        return { kind: "declined", asked: false };
+    if (wanted !== "impeccable") {
+        const yes = await askAesthetic();
+        if (yes === false)
+            return { kind: "declined", asked: true };
+    }
+    try {
+        execFileSync("npx", ["-y", `impeccable@${IMPECCABLE_VERSION}`, "install", "-y", "--providers=claude", "--project"], { cwd: root, stdio: "pipe" });
+        return { kind: "installed", version: impeccableIn(root) ?? IMPECCABLE_VERSION };
+    }
+    catch (e) {
+        const err = e;
+        return {
+            kind: "failed",
+            why: err.stderr?.toString().trim().split("\n").filter(Boolean).pop() ??
+                err.message ??
+                "unknown",
+        };
+    }
+}
+/** O gerenciador que o projeto já usa, pelo lockfile - instalar com outro deixaria dois lockfiles brigando. */
+export function packageManagerOf(root) {
+    if (existsSync(join(root, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(root, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock")))
+        return "bun";
+    return "npm";
+}
+export function addDevArgs(pm, spec) {
+    if (pm === "npm")
+        return ["install", "--save-dev", "--no-audit", "--no-fund", spec];
+    if (pm === "bun")
+        return ["add", "--dev", spec];
+    return ["add", "--save-dev", spec];
+}
+/**
+ * O CLI COMO DEPENDÊNCIA DO PROJETO - é o que faz o fim do turno rodar a versão dele, e ~10x mais rápido que o `npx`
+ * (medido em 27/07, ver `hookCommand`). O `connect` escolhe sozinho o local quando ele está em `node_modules`, então
+ * esta instalação vem ANTES dele.
+ *
+ * `spec` existe para provar uma versão antes do publish (um tarball do `npm pack`); o padrão é a versão que roda.
+ */
+async function installLocalCli(root, spec) {
+    const pm = packageManagerOf(root);
+    try {
+        execFileSync(pm, addDevArgs(pm, spec), { cwd: root, stdio: "pipe" });
+        return { ok: true, pm };
+    }
+    catch (e) {
+        const err = e;
+        const why = err.stderr?.toString().trim().split("\n").filter(Boolean).pop() ??
+            err.message ??
+            "unknown";
+        return { ok: false, pm, why };
+    }
+}
+export async function openTheDoor(opts) {
+    const { root, version } = opts;
+    const pkgPath = join(root, "package.json");
+    const hasPackage = existsSync(pkgPath);
+    const local = hasPackage
+        ? await installLocalCli(root, opts.pkg ?? `synthesisui@${version}`)
+        : null;
+    const layer = await aestheticLayer(root, opts.aesthetic);
+    ligarCaptura();
+    let failed = null;
+    try {
+        await connect({
+            dir: root,
+            version,
+            ...(opts.registry ? { registry: opts.registry } : {}),
+            hook: true,
+            mcp: true,
+            agents: "claude",
+            interactive: false,
+        });
+    }
+    catch (e) {
+        failed = e;
+    }
+    const connectLines = desligarCaptura();
+    if (failed) {
+        for (const line of [...opts.configLines, ...connectLines])
+            console.log(line);
+        throw failed;
+    }
+    const installed = hasPackage
+        ? (JSON.parse(await readFile(pkgPath, "utf8")).devDependencies?.synthesisui ?? null)
+        : null;
+    console.log(section("SynthesisUI is set up"));
+    console.log("");
+    console.log(body(local?.ok
+        ? `✓ the CLI       synthesisui ${version} in your devDependencies (${local.pm}) - the check runs this one`
+        : local
+            ? `· the CLI       not installed (${local.why}) - the check runs it through npx, slower`
+            : "· the CLI       no package.json here - the check runs it through npx, slower"));
+    console.log(body(`✓ your agent    Claude Code: the check at the end of each turn, ${MCP_TOOL_COUNT} tools, ${SKILLS.length} skills`));
+    console.log(body(layer.kind === "found"
+        ? `✓ aesthetic     impeccable ${layer.version} was already here - left exactly as it is`
+        : layer.kind === "installed"
+            ? `✓ aesthetic     impeccable ${layer.version}, by its own installer - it creates the first look`
+            : layer.kind === "failed"
+                ? `· aesthetic     impeccable did not install (${layer.why}) - run init again to retry`
+                : "· aesthetic     none - the first look comes from your agent alone, with no design direction behind it"));
+    if (layer.kind === "declined")
+        console.log(body(paint.faint("                add it later: npx synthesisui init --aesthetic impeccable")));
+    if (layer.kind === "installed" && opts.aesthetic !== "impeccable" && !process.stdin.isTTY)
+        console.log(body(paint.faint("                installed by default - `--aesthetic none` leaves it out")));
+    console.log(body("✓ no account    nothing here needs one"));
+    if (installed && local?.ok === false)
+        console.log(body(paint.faint(`  (package.json already lists synthesisui ${installed})`)));
+    console.log("");
+    console.log(section("Next"));
+    console.log("");
+    console.log(body("Open your agent here and ask for your first screen:"));
+    console.log("");
+    console.log(snippet(["claude", '"make a landing page for <what you are building>"']));
+    console.log("");
+    console.log(body("When the first screen is done, the agent offers to read it and turn what it decided into your system."));
+}

package/dist/index.js

@@ -50,7 +50,8 @@ const HELP = `synthesisui - bring SynthesisUI design systems into your project
 Usage - deterministic, FREE:
   synthesisui login [options]              connect the CLI to your account (device-flow; --force to switch accounts)
   synthesisui logout                       sign out of this machine (removes the saved token)
-  synthesisui init [options]               write _synthesisui/config.json (target, dirs); --ds to bring one in
+  synthesisui init [options]               start here: the CLI in your devDependencies, your agent wired, no account;
+                                           --ds <slug> brings a published system in instead
   synthesisui list [options]               list the published design systems
   synthesisui list --mine                  your own systems, with their group
   synthesisui add <slug> [options]         materialize a DS into _synthesisui/ds/<slug>/
@@ -125,6 +126,8 @@ Options:
   --dir <path>       consumer project root (default: current directory)
   --version <n>      install a specific version (default: latest)
   --ds <slug>        init: bring this DS in right away · generate: target DS (default: installed)
+  --package <spec>   init: what to add to devDependencies (default: synthesisui@<this version>)
+  --aesthetic <a>    init: impeccable | none - the layer that creates the first look (default: impeccable, asked in a terminal)
   --name <name>      import: the NAME of the system, which is what its install slug
                      comes from - and the slug never changes. Also the preferred
                      component name for generate.
@@ -165,7 +168,7 @@ Examples:
   synthesisui adopt                        # you already have a system: start here
   synthesisui import --dry                 # see the census before anything is sent
   synthesisui login
-  synthesisui init --target next
+  synthesisui init                         # an empty project: one command, then ask your agent
   synthesisui init --target next --ds halogen   bootstrap + bring a system in
   synthesisui doctor
   synthesisui doctor apps/web packages/ui   # scope the read in a monorepo
@@ -574,6 +577,8 @@ async function main() {
                 ...(typeof flags["theme-in"] === "string"
                     ? { themeIn: flags["theme-in"] }
                     : {}),
+                ...(typeof flags.package === "string" ? { pkg: flags.package } : {}),
+                ...(typeof flags.aesthetic === "string" ? { aesthetic: flags.aesthetic } : {}),
                 cli: CLI_VERSION,
             });
             break;

package/dist/install-marks.js

@@ -350,7 +350,12 @@
  * sem eles, a linha que ensina o agente a oferecer a leitura (`synthesisui read`) e a confirmar (`read --confirm`). Uma
  * pasta escrita antes não fala de papéis nem da leitura.
  */
-export const MATERIALISER_SINCE = "0.16.500";
+/**
+ * 0.16.500 -> 0.16.501 em 18/10, e o passo 1 dá **SIM** (jornada "um instalador, uma porta"): num projeto sem sistema, o
+ * bloco do `CLAUDE.md` ensina a leitura da primeira tela em vez do `/sui-import-ds`; com o `rules.json` e o impeccable no
+ * projeto, diz que o revisor dele é só da criação. Uma pasta escrita antes manda o agente importar e não fala do revisor.
+ */
+export const MATERIALISER_SINCE = "0.16.501";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *
@@ -574,7 +579,13 @@ export const COUNTED_DIFFERENTLY = "this run counts a value as named only when Y
  * vez) e acha a raiz pelo projeto - não pela pasta onde o terminal do agente parou, que deixava turnos inteiros sem
  * conferência. Um hook pinado antes não confere papel nenhum.
  */
-export const CHECKER_SINCE = "0.16.500";
+/**
+ * 0.16.500 -> 0.16.501 em 18/10, e o passo 1 dá **SIM** (jornada "um instalador, uma porta"): o fim do turno pede ao agente,
+ * uma vez, que ofereça a leitura quando a primeira tela aparece num projeto sem sistema nenhum. Um hook pinado antes nunca
+ * oferece. E a checagem por papel lê CSS Modules (`className={styles.h2}`, o tamanho no `.module.css`): um hook anterior
+ * não confere papel nenhum numa página escrita assim.
+ */
+export const CHECKER_SINCE = "0.16.501";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *

package/dist/role-rules.js

@@ -1,5 +1,6 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { basename, extname, join } from "node:path";
+import { basename, dirname, extname, join } from "node:path";
 export async function loadRoleRules(root) {
     const ds = join(root, "_synthesisui", "ds");
     const slugs = await readdir(ds).catch(() => []);
@@ -44,6 +45,116 @@ function sizeClass(attrs) {
         return null;
     return found.sort((a, b) => (pxOf(b) ?? 0) - (pxOf(a) ?? 0))[0] ?? null;
 }
+/**
+ * A CLASSE DE UM CSS MODULE - achado na rodada real da porta (18/10, `regua/rodadas/porta-2`): o impeccable escreveu a
+ * landing com `className={styles.h2}` (117 usos, 4 `.module.css`), a leitura achou 5 papéis e o `--confirm` gravou ZERO,
+ * porque a identidade de um papel era só a classe de tamanho do Tailwind. Uma de três criações medidas foi assim.
+ *
+ * A identidade passa a ser o ARQUIVO e o nome local - `page.module.css .h2` -, que é o que a pessoa acha no código e o
+ * que o hash do build não muda. O apelido do import (`styles`, `s`) não entra: dois arquivos podem chamar o mesmo módulo
+ * de jeitos diferentes.
+ */
+export function moduleClassName(file, local) {
+    return `${file} .${local}`;
+}
+/** Os imports de CSS Module de um arquivo: apelido -> o caminho como foi escrito. */
+function moduleImports(src) {
+    const out = new Map();
+    for (const m of src.matchAll(/import\s+(\w+)\s+from\s+["']([^"']+\.module\.s?css)["']/g))
+        out.set(m[1], m[2]);
+    return out;
+}
+/** As classes de módulo dentro de um `className={...}`, na ordem em que aparecem. */
+function moduleClasses(attrs, imports) {
+    const expr = attrs.match(/className=\{([^}]*(?:\}[^}]*)?)\}/)?.[1] ?? "";
+    const out = [];
+    for (const m of expr.matchAll(/\b(\w+)(?:\.([A-Za-z_][\w-]*)|\[["']([\w-]+)["']\])/g)) {
+        const path = imports.get(m[1]);
+        const local = (m[2] ?? m[3]);
+        if (path && local)
+            out.push({ name: moduleClassName(basename(path), local), path, local });
+    }
+    return out;
+}
+/** As classes escritas como texto em `className="a b"` (ou num template sem expressão no meio do nome). */
+function plainClasses(attrs) {
+    const lit = attrs.match(/className=\{?\s*["'`]([^"'`]*)["'`]/)?.[1] ?? "";
+    return lit.split(/\s+/).filter((t) => /^[A-Za-z_][\w-]*$/.test(t));
+}
+/** O `font-size` de uma classe dentro do `.module.css` - o maior de um `clamp()` (o desktop), `rem` a 16px. */
+export function modulePx(css, local) {
+    let best = null;
+    const esc = local.replace(/[-]/g, "\\-");
+    for (const m of css.matchAll(new RegExp(`([^{}]*\\.${esc}(?![\\w-])[^{}]*)\\{([^}]*)\\}`, "g"))) {
+        const v = m[2].match(/font-size\s*:\s*([^;]+)/)?.[1]?.trim();
+        if (!v)
+            continue;
+        const parts = v.startsWith("clamp(") ? v.slice(6, -1).split(",") : [v];
+        for (const p of parts) {
+            const n = p.trim().match(/^([\d.]+)(px|rem)$/);
+            if (!n)
+                continue;
+            const px = Number(n[1]) * (n[2] === "rem" ? 16 : 1);
+            if (best === null || px > best)
+                best = px;
+        }
+    }
+    return best;
+}
+/**
+ * A CLASSE GLOBAL - achado no juízo dele (19/10, a landing da Naiker, `synthesisui-tests/juizo-porta`): o impeccable
+ * escreveu os títulos com classes comuns, `className="section-title"`, e o tamanho no `globals.css`. A leitura achou os
+ * papéis (h1 180, h2 70,4, h3 28,8) e o `--confirm` gravou ZERO, calado - o mesmo defeito do CSS Modules (porta-2) numa
+ * terceira forma de escrever estilo.
+ *
+ * A identidade é a mesma forma do módulo: o arquivo e a classe, `globals.css .section-title`. Vale a classe que tem um
+ * `font-size` numa folha de estilo comum do projeto (não `.module.css`), na ordem em que vem - a do próprio elemento
+ * primeiro.
+ */
+export function globalStyles(root) {
+    const out = [];
+    const walk = (d) => {
+        let names = [];
+        try {
+            names = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            if (n === "node_modules" || n.startsWith(".") || n === "_synthesisui" || n === "public")
+                continue;
+            const p = join(d, n);
+            let dir = false;
+            try {
+                dir = statSync(p).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (dir)
+                walk(p);
+            else if (/\.s?css$/.test(n) && !/\.module\.s?css$/.test(n))
+                out.push({ file: n, css: readFileSync(p, "utf8") });
+        }
+    };
+    walk(existsSync(join(root, "src")) ? join(root, "src") : root);
+    if (existsSync(join(root, "app")) && existsSync(join(root, "src")))
+        walk(join(root, "app"));
+    return out;
+}
+export function globalClassOf(tokens, styles) {
+    for (const tok of tokens) {
+        if (!/^[A-Za-z_][\w-]*$/.test(tok))
+            continue;
+        for (const st of styles) {
+            const px = modulePx(st.css, tok);
+            if (px !== null)
+                return { name: moduleClassName(st.file, tok), local: tok, px };
+        }
+    }
+    return null;
+}
 /** Dentro de um `.map(` ainda aberto = o título se repete = é de cartão. A mesma pergunta que a régua faz ao DOM. */
 function insideMap(src, at) {
     const before = src.slice(0, at);
@@ -56,16 +167,31 @@ function insideMap(src, at) {
     return depth > 0;
 }
 const near = (a, b) => Math.abs(a - b) / Math.max(a, b) < 0.03;
-export function checkRoles(rel, src, rules) {
+export function checkRoles(rel, src, rules, root) {
     if (rules.enforce === false || !/\.(tsx|jsx)$/.test(rel))
         return [];
+    const imports = moduleImports(src);
+    const cssOf = new Map();
+    const pxOfModule = (path, local) => {
+        if (!root)
+            return null;
+        const file = join(root, dirname(rel), path);
+        if (!cssOf.has(file))
+            cssOf.set(file, existsSync(file) ? readFileSync(file, "utf8") : "");
+        return modulePx(cssOf.get(file), local);
+    };
+    /** As folhas de estilo comuns do projeto, lidas uma vez e só se algum título usar classe sem tamanho do Tailwind. */
+    let globals = null;
+    const styles = () => (globals ??= root ? globalStyles(root) : []);
     const component = basename(rel, extname(rel));
     const known = new Set((rules.knownDrift ?? []).filter((d) => d.at.startsWith(rel)).map((d) => d.class));
     const section = rules.roles.find((r) => r.element === "h2" && r.context === "section");
     const out = [];
     for (const m of src.matchAll(/<(h1|h2|h3)\b([^>]*)>/g)) {
         const el = m[1];
-        const cls = sizeClass(m[2]);
+        const mod = sizeClass(m[2]) ? null : (moduleClasses(m[2], imports)[0] ?? null);
+        const glob = sizeClass(m[2]) || mod ? null : globalClassOf(plainClasses(m[2]), styles());
+        const cls = sizeClass(m[2]) ?? mod?.name ?? glob?.name ?? null;
         if (!cls)
             continue;
         const line = src.slice(0, m.index).split("\n").length;
@@ -78,7 +204,7 @@ export function checkRoles(rel, src, rules) {
             continue;
         if (known.has(bare))
             continue;
-        const px = pxOf(bare);
+        const px = mod ? pxOfModule(mod.path, mod.local) : glob ? glob.px : pxOf(bare);
         const role = mine.find((r) => r.context === context) ?? mine[0];
         const brk = rules.breaks.find((b) => b.class === bare);
         if (brk) {
@@ -111,6 +237,8 @@ export function checkRoles(rel, src, rules) {
      * quebra fora do componente dela. A cópia com OUTRO tamanho (41,6 no lugar de 57,6) não aparece no código - é a régua
      * da página renderizada que vê ("o mesmo motivo"), no fecho do turno.
      */
+    /* duas quebras podem morar na mesma classe (a capa da porta-2: "Batch" e "Nº 01" em `.batch span`) - uma linha basta */
+    const said = new Set();
     for (const b of rules.breaks) {
         if (!b.class || b.allowedIn === component)
             continue;
@@ -118,9 +246,14 @@ export function checkRoles(rel, src, rules) {
             if (/^h[1-3]$/.test(m[1]))
                 continue;
             const cls = m[2].match(/className=\{?\s*["'`]([^"'`]*)["'`]/)?.[1] ?? "";
-            if (!` ${cls} `.includes(` ${b.class} `))
+            const mods = moduleClasses(m[2], imports).map((c) => c.name);
+            const globs = b.class.includes(" .") && !b.class.includes(".module.") ? cls.split(/\s+/).filter(Boolean).map((t) => globalClassOf([t], styles())?.name) : [];
+            if (!` ${cls} `.includes(` ${b.class} `) && !mods.includes(b.class) && !globs.includes(b.class))
                 continue;
             const line = src.slice(0, m.index).split("\n").length;
+            if (said.has(`${line} ${b.class}`))
+                continue;
+            said.add(`${line} ${b.class}`);
             out.push(`  line ${line}  <${m[1]}> ${b.class} is the break "${b.rule}" the person chose for ${b.allowedIn} (${b.home}). Reuse that component here instead of copying the motif, or ask whether this page gets its own.`);
         }
     }

package/package.json

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