synthesisui 0.16.159 → 0.16.161

package/dist/agent-wiring.js

@@ -36,6 +36,22 @@ export async function hookCommand(root, version) {
         ? "npx --no-install synthesisui hook"
         : `npx synthesisui@${version} hook`;
 }
+/**
+ * COMO A SESSÃO CHAMA O CLI, e por que este NÃO é pinado.
+ *
+ * O hook de escrita é pinado porque roda dezenas de vezes por sessão e um verificador que muda sob
+ * você a cada edit é indebugável. Este roda UMA vez, e o trabalho dele é justamente dizer o que está
+ * atrasado - inclusive o próprio CLI. Um `align` pinado no dia do `connect` não conhece nenhuma
+ * verificação escrita depois, e passa a garantir silêncio em vez de alinho.
+ *
+ * O custo do `npx` (720ms-1.5s, medido em 27/07) é pago uma vez na abertura, não por escrita.
+ */
+export async function alignCommand(root) {
+    const local = join(root, "node_modules", ".bin", "synthesisui");
+    return (await exists(local))
+        ? "npx --no-install synthesisui align"
+        : "npx synthesisui@latest align";
+}
 /**
  * Returns the command that IS in the file, not the one we would have written.
  *
@@ -211,9 +227,45 @@ export async function wireAgent(root, version, want) {
         command: hook.command,
         hook: hook.status,
         ...(hook.was ? { was: hook.was } : {}),
+        /**
+         * A VERIFICAÇÃO DE ABERTURA vai junto do hook de escrita, e por um motivo medido: as onze
+         * ferramentas MCP são todas PULL, o agente só descobre um desalinho se resolver perguntar, e o
+         * único hook instalado rodava DEPOIS de uma escrita - tarde demais para dizer "você não está
+         * logado" ou "este sistema não sabe de onde foi medido".
+         */
+        session: want.hook
+            ? await wireSessionStart(root, await alignCommand(root))
+            : "skipped",
         mcp: want.mcp ? await wireMcp(root, version) : "skipped",
     };
 }
+/**
+ * O hook `SessionStart`, escrito com a mesma disciplina do de escrita: vizinho nenhum é tocado, e um
+ * comando escrito à mão fica como está. Só um `align` nosso apontando para outro lugar é substituído.
+ */
+async function wireSessionStart(root, command) {
+    const dir = join(root, ".claude");
+    const path = join(dir, "settings.json");
+    const settings = await readJson(path);
+    const hooks = (settings.hooks ?? {});
+    const entries = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    for (const entry of entries)
+        for (const h of entry.hooks ?? []) {
+            const was = h.command ?? "";
+            if (!/synthesisui(@[\w.-]+)?\s+align/.test(was))
+                continue;
+            if (was === command)
+                return "already there";
+            h.command = command;
+            await mkdir(dir, { recursive: true });
+            await writeFile(path, `${JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: entries } }, null, 2)}\n`, "utf8");
+            return "updated";
+        }
+    entries.push({ hooks: [{ type: "command", command }] });
+    await mkdir(dir, { recursive: true });
+    await writeFile(path, `${JSON.stringify({ ...settings, hooks: { ...hooks, SessionStart: entries } }, null, 2)}\n`, "utf8");
+    return "added";
+}
 /**
  * Whether THIS project already has the hook.
  *

package/dist/commands/add.js

@@ -4,10 +4,43 @@ import { syncClaudeMd } from "../claude-md.js";
 import { readProjectConfig, resolveRegistry } from "../config.js";
 import { customFontFamilies, googleFontsHref, nextFontSnippet, } from "../fonts.js";
 import { buildGuide } from "../guide.js";
+import { censusScope } from "../measured-scope.js";
 import { body as line, section, snippet } from "../output.js";
 import { fetchDesignSystem } from "../registry.js";
 import { describeFiltered, ruleApplies, rulesForProject, } from "../rule-filter.js";
 import { detectStack } from "../stack.js";
+/**
+ * QUAL METADE DESTA PASTA UM TIME COMMITA.
+ *
+ * Medido no repo do dono em 06/08: `_synthesisui/` não estava no gitignore E não tinha um único
+ * arquivo rastreado. Ou seja, a pasta existia só na máquina de quem rodou o import - todo clone, e
+ * todo colega, começava sem governança nenhuma, e nada dizia isso a ninguém.
+ *
+ * A divisão não é gosto, é o que cada arquivo É:
+ *
+ *     .lock, ds/<slug>/**   a IDENTIDADE e o CSS que a app importa. Sem eles o build de um colega
+ *                           não tem tokens. Versionar.
+ *     census.json           0,5 MB, regravado inteiro a cada medição. Versionar é conflito toda vez.
+ *     ledger.jsonl          registro local, append-only, uma linha por escrita. Conflito garantido.
+ *
+ * Escrito uma vez e nunca reescrito: um arquivo que alguém ajustou é decisão dele.
+ */
+async function writeGovernanceIgnore(projectRoot) {
+    const path = join(projectRoot, "_synthesisui", ".gitignore");
+    try {
+        await access(path);
+        return;
+    }
+    catch {
+        // não existe - escrever
+    }
+    await writeFile(path, "# 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" +
+        "# both are rewritten in full on every run and would conflict on every merge.\n" +
+        "census.json\n" +
+        "ledger.jsonl\n" +
+        "not-expressed.md\n", "utf8");
+}
 async function readRootLock(path) {
     try {
         return JSON.parse(await readFile(path, "utf8"));
@@ -62,14 +95,25 @@ export async function add(slug, opts) {
             `@import "./v${payload.version}/${filename}";\n`, "utf8");
     }
     // 5. root pointer
+    /**
+     * A medição FRESCA vence a cópia anterior, e por isso lê o censo em vez do lock: um `--scope` novo
+     * chega pelo censo que acabou de rodar, e ler o lock aqui congelaria o primeiro para sempre. Sem
+     * censo (um `add` puro, sem import antes), o que o lock já dizia é preservado.
+     */
+    const measured = await censusScope(projectRoot);
+    const scope = measured.system ?? prev?.scope ?? null;
+    const usage = measured.usage.length > 0 ? measured.usage : (prev?.usage ?? []);
     const lock = {
         slug: payload.slug,
         name: payload.name,
         version: payload.version,
         registry: base,
         fetchedAt: new Date().toISOString(),
+        ...(scope ? { scope } : {}),
+        ...(usage.length > 0 ? { usage } : {}),
     };
     await writeFile(rootLockPath, `${JSON.stringify(lock, null, 2)}\n`, "utf8");
+    await writeGovernanceIgnore(projectRoot);
     // 5b. governance rules (personal DS) → rules.md at the slug root (stable path,
     //     highest authority; the GUIDE tells the agent to read it first)
     /**

package/dist/commands/align.js

@@ -0,0 +1,133 @@
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { readEvents } from "../doctor/ledger.js";
+import { measuredScope } from "../measured-scope.js";
+async function locksIn(root) {
+    const dsDir = join(root, "_synthesisui", "ds");
+    const entries = await readdir(dsDir, { withFileTypes: true }).catch(() => []);
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const raw = await readFile(join(dsDir, entry.name, ".lock"), "utf8").catch(() => null);
+        if (!raw)
+            continue;
+        try {
+            out.push(JSON.parse(raw));
+        }
+        catch {
+            // lock ilegível - o `status` já reporta isso com o nome do arquivo
+        }
+    }
+    return out;
+}
+async function credentials(home) {
+    const raw = await readFile(join(home, ".synthesisui", "credentials.json"), "utf8").catch(() => null);
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A metade que não depende de rede.
+ *
+ * Separada de propósito: ela é a que sempre roda, e é testável sem servidor nenhum.
+ */
+export async function localMisalignments(root, 
+/**
+ * `home` é injetável porque a SESSÃO mora nele e não no repo - e uma verificação que lê o home da
+ * máquina que roda o teste não é verificável: ela passa ou falha conforme quem está logado ali.
+ */
+opts = {}) {
+    const { cli, home = homedir() } = opts;
+    const out = [];
+    const locks = (await locksIn(root)).filter((l) => l.slug && !l.adopted);
+    /** Sem sistema instalado não há alinho a cobrar - não é desalinho, é um repo sem DS. */
+    if (locks.length === 0)
+        return out;
+    if (locks.length > 1)
+        out.push({
+            says: `${locks.length} design systems are installed here (${locks
+                .map((l) => l.slug)
+                .join(", ")}) - commands act on the first, so one of them is not being governed`,
+        });
+    const lock = locks[0];
+    const creds = await credentials(home);
+    if (!creds)
+        out.push({
+            says: "No session on this machine. A token belongs to the machine, not to the repo, so a fresh clone always lands here.",
+            run: "npx synthesisui login",
+        });
+    else if (creds.registry && lock.registry && creds.registry !== lock.registry)
+        out.push({
+            says: `Your session is for ${creds.registry} and this system came from ${lock.registry}. That answers 401, which reads as an expired session on a host that never issued one.`,
+            run: `npx synthesisui login --registry ${lock.registry}`,
+        });
+    /**
+     * O ESCOPO, que é o desalinho mais caro e o mais silencioso: sem ele o `sync` mede o repo inteiro
+     * e manda os componentes de todos os apps para um sistema que é uma biblioteca (06/08, 338 num
+     * sistema de 36).
+     */
+    const scope = await measuredScope(root);
+    if (!scope.system && scope.usage.length === 0)
+        out.push({
+            says: `"${lock.slug}" does not record where it was measured, so a re-measure would read this whole repo instead of the folder the system came from. Sync asks once and remembers the answer.`,
+            /**
+             * O COMANDO QUE ELA JÁ RODA, e nunca um sexto.
+             *
+             * Isto dizia `import --dry --scope <folder>`, que não está no vocabulário de quem usa isto -
+             * `connect`, `login`, `doctor`, `sync`, `upgrade`, e a skill. O `align` é a única coisa que
+             * fala com a pessoa sem ela pedir, e falar ensinando uma palavra que ela nunca viu transfere
+             * para ela um problema que era nosso. O `sync` absorveu o caso - ver `askForScope`.
+             */
+            run: "npx synthesisui sync",
+        });
+    const events = await readEvents(root).catch(() => []);
+    if (events.length > 0)
+        out.push({
+            says: `${events.length} checked write${events.length === 1 ? "" : "s"} recorded here and not sent - the platform is scoring this repo on older evidence.`,
+            run: "npx synthesisui sync",
+        });
+    if (cli && lock.version == null)
+        out.push({
+            says: `"${lock.slug}" has no version recorded, so nothing can tell whether the CSS in this repo is the one the platform publishes.`,
+            run: "npx synthesisui upgrade",
+        });
+    return out;
+}
+/**
+ * A linha que a sessão vê.
+ *
+ * Uma frase por desalinho e o comando ao lado - sem cabeçalho, sem contagem, sem moldura. Isto é
+ * injetado no contexto de um agente, e cada linha decorativa é contexto que não é sobre o trabalho
+ * dele.
+ */
+export function describeMisalignments(items) {
+    if (items.length === 0)
+        return "";
+    return [
+        "Before this session starts, this environment is out of alignment with the design system that governs it:",
+        ...items.map((m) => `  - ${m.says}${m.run ? `\n      ${m.run}` : ""}`),
+    ].join("\n");
+}
+/**
+ * `synthesisui align` - o comando que o hook de sessão roda.
+ *
+ * Sai silencioso e com código 0 quando está tudo alinhado, porque um hook que fala toda vez deixa de
+ * ser lido. E nunca falha: um ambiente que não dá para verificar não pode impedir alguém de
+ * trabalhar.
+ */
+export async function align(opts) {
+    const root = resolve(opts.dir ?? process.cwd());
+    const items = await localMisalignments(root, {
+        ...(opts.cli ? { cli: opts.cli } : {}),
+    }).catch(() => []);
+    const text = describeMisalignments(items);
+    if (text)
+        console.log(text);
+}

package/dist/commands/connect.js

@@ -50,6 +50,15 @@ export async function connect(opts) {
                     `✓ .claude/settings.json  the check moved from ${wired.was?.match(/synthesisui@(\d+\.\d+\.\d+)/)?.[1] ?? "an older version"} to this one`
                 : "· .claude/settings.json  already had it"));
         console.log(snippet([wired.command]));
+        /**
+         * A SEGUNDA COSTURA, dita por nome. As onze ferramentas MCP são PULL e o hook de escrita roda
+         * DEPOIS de uma escrita - nenhum dos dois chega a tempo de dizer "você não está logado nesta
+         * máquina" ou "este sistema não sabe de onde foi medido". O `SessionStart` é o único que chega.
+         */
+        if (wired.session !== "skipped")
+            console.log(body(wired.session === "already there"
+                ? "· .claude/settings.json  the session check was already there"
+                : `✓ .claude/settings.json  every session now opens with what this environment is missing${wired.session === "updated" ? ", pointed at this version" : ""}`));
     }
     /**
      * OS CAMINHOS DE MCP, POR NOME - e o número vem da LISTA, não da minha memória.

package/dist/commands/import.js

@@ -79,7 +79,7 @@ const MAX_PER_KIND = {
  * comes from wherever the vocabulary is centralised, and each app is a consumer
  * measured against it.
  */
-async function siblingProjects(root) {
+export async function siblingProjects(root) {
     const apps = [];
     const shared = [];
     for (const group of ["apps", "packages", "libs"]) {

package/dist/commands/sync.js

@@ -3,9 +3,10 @@ import { join, resolve } from "node:path";
 import { readToken, resolveRegistry } from "../config.js";
 import { readEvents } from "../doctor/ledger.js";
 import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
+import { measuredScope, rememberScope } from "../measured-scope.js";
 import { body, paint, section, snippet } from "../output.js";
 import { repoStateOf } from "../repo-state.js";
-import { resolveReadParts, takeCensus } from "./import.js";
+import { resolveReadParts, siblingProjects, takeCensus } from "./import.js";
 /**
  * What each decision means ON THIS MACHINE - the card decides, the sync
  * enacts. The web never touches the local file; this line is printed right
@@ -191,13 +192,50 @@ export async function remeasure(args) {
         console.log(paint.blue(snippet(["npx synthesisui@latest connect"])));
         console.log(body(paint.faint("That rewires the hook and the tools to the new version - the editor picks them up on the next session.")));
     }
+    /**
+     * O ESCOPO SAI DO DISCO ANTES DE SAIR DO SERVIDOR.
+     *
+     * Ele mora nos dois lugares, e o do disco é o que não pode se perder: o censo local É a foto da
+     * última medição e carrega o `scope` que a mediu. O servidor guarda uma cópia, e uma cópia pode
+     * ser sobrescrita - em 06/08 foi, e o sistema ficou sem escopo nenhum lá.
+     *
+     * O preço daquilo não foi um número errado, foi um LOOP: sem escopo, esta linha media o repo
+     * inteiro, mandava 338 componentes de app para um sistema de 36, e o `sync` seguinte fazia de
+     * novo. Perguntar ao servidor uma coisa que está do lado de cá é o que fechava o ciclo.
+     *
+     * O servidor continua valendo como segunda fonte: um clone fresco tem o `.lock` e não tem censo.
+     */
+    const local = await measuredScope(root);
+    let scope = local.system ?? stored.scope ?? null;
+    let usage = local.usage.length > 0 ? local.usage : (stored.usage ?? []);
+    /**
+     * E QUANDO NINGUÉM SABE, ESTE COMANDO PERGUNTA - uma vez, e grava a resposta.
+     *
+     * Um sistema que perdeu o escopo só tinha uma volta: `import --scope`. Isso é uma SEXTA palavra
+     * no vocabulário de quem usa isto (`connect`, `login`, `doctor`, `sync`, `upgrade`, e a skill), e
+     * uma mensagem que ensina uma palavra nova transfere para a pessoa um problema que era nosso.
+     *
+     * Então o comando que ela já roda absorve o caso: os candidatos saem do próprio repo, a resposta
+     * vai para o `.lock`, e a pergunta não volta.
+     */
+    if (!scope) {
+        const asked = await askForScope(root);
+        if (asked) {
+            scope = asked.scope;
+            if (asked.usage.length > 0)
+                usage = asked.usage;
+            await rememberScope(root, slug, scope, usage);
+        }
+    }
     console.log(section("Measuring your repository again"));
-    console.log(body(paint.faint(`${stored.scope ? `scope ${stored.scope}` : "the whole repo"} · the reading you already authored travels unchanged`)));
-    const census = await takeCensus(stored.scope ? join(root, stored.scope) : root, {
-        ...(stored.scope ? { scopeLabel: stored.scope } : {}),
+    console.log(body(paint.faint(`${scope ? `scope ${scope}` : "the whole repo"}${local.system && local.system !== stored.scope
+        ? " · read from your own census, which is where the last measurement recorded it"
+        : ""} · the reading you already authored travels unchanged`)));
+    const census = await takeCensus(scope ? join(root, scope) : root, {
+        ...(scope ? { scopeLabel: scope } : {}),
         ...(args.cli ? { cli: args.cli } : {}),
         /** O `--usage` é EVIDÊNCIA e leva rótulo: sem ele o censo não sabe de que app o número veio. */
-        usage: (stored.usage ?? []).map((u) => ({
+        usage: usage.map((u) => ({
             path: join(root, u),
             label: u,
         })),
@@ -316,3 +354,44 @@ export async function installedSlug(root) {
     }
     return null;
 }
+/**
+ * DE ONDE ESTE SISTEMA FOI MEDIDO - perguntado uma vez, com os candidatos do próprio repo.
+ *
+ * Os nomes não são digitados: `siblingProjects` já separa o que é biblioteca compartilhada do que é
+ * app, que é exatamente a distinção entre o SISTEMA e quem o CONSOME. Um monorepo responde em uma
+ * tecla; um repo de app único nem chega aqui, porque a raiz é a resposta óbvia e ela não precisa de
+ * pergunta.
+ *
+ * Sem terminal interativo devolve `null` e a medição segue como antes - um CI não pode travar
+ * esperando alguém, e medir a raiz num CI é o comportamento que ele sempre teve.
+ */
+async function askForScope(root) {
+    const { apps, shared } = await siblingProjects(root);
+    if (shared.length === 0)
+        return null;
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return null;
+    console.log(section("Where does this system come from?"));
+    console.log(body("Nothing here records it, so a re-measure would read this whole repo - which produces the average of every app you have, and that is a diagnosis rather than a system."));
+    shared.forEach((name, i) => {
+        console.log(body(`  ${i + 1}. ${name}`));
+    });
+    console.log(body(`  ${shared.length + 1}. the whole repo`));
+    if (apps.length > 0)
+        console.log(body(paint.faint(`${apps.length} app${apps.length === 1 ? "" : "s"} travel as evidence either way: ${apps.slice(0, 3).join(", ")}${apps.length > 3 ? ", …" : ""}`)));
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question("  which one? [1]: ")).trim();
+        const pick = answer === "" ? 1 : Number(answer);
+        if (!Number.isInteger(pick) || pick < 1 || pick > shared.length)
+            return null;
+        return { scope: shared[pick - 1], usage: apps };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import { absorb } from "./commands/absorb.js";
 import { add } from "./commands/add.js";
 import { adopt } from "./commands/adopt.js";
 import { advise } from "./commands/advise.js";
+import { align } from "./commands/align.js";
 import { ci } from "./commands/ci.js";
 import { clean } from "./commands/clean.js";
 import { component } from "./commands/component.js";
@@ -547,6 +548,13 @@ async function main() {
                 yes: args.includes("--yes"),
             });
             break;
+        /**
+         * O que o hook `SessionStart` roda. Silencioso quando está alinhado, e nunca falha - ver
+         * `align.ts` para os nove estados e por que sete deles não tinham verificação nenhuma.
+         */
+        case "align":
+            await align({ dir, cli: CLI_VERSION });
+            break;
         case "request": {
             // `synthesisui request` lists; `request component --name x --for "..."`
             // files; `request --done <id>` closes. The agent's front door is the MCP

package/dist/measured-scope.js

@@ -1,6 +1,51 @@
-import { readFile, stat } from "node:fs/promises";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 const EMPTY = { system: null, usage: [], from: "none" };
+/**
+ * O ESCOPO NO PONTEIRO DO SISTEMA, que é onde ele não se perde.
+ *
+ * O censo é grande (0,5 MB), é regravado a cada medição e ninguém versiona um arquivo assim sem
+ * pagar conflito. O `.lock` tem cinco campos e é o arquivo desta pasta que um time COMMITA - então é
+ * ele que faz um clone fresco saber de onde este sistema foi medido, sem uma ida à rede e sem
+ * depender de uma cópia no servidor que já foi sobrescrita uma vez (06/08).
+ *
+ * Um lock sem `scope` é o caso de todo sistema instalado antes disto: cai no censo, como antes.
+ */
+async function scopeInLock(root) {
+    const dsDir = join(root, "_synthesisui", "ds");
+    const names = await readdir(dsDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of names) {
+        if (!entry.isDirectory())
+            continue;
+        const raw = await readFile(join(dsDir, entry.name, ".lock"), "utf8").catch(() => null);
+        if (!raw)
+            continue;
+        let lock;
+        try {
+            lock = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        const scope = typeof lock.scope === "string" && lock.scope.trim()
+            ? lock.scope.trim()
+            : null;
+        const usage = Array.isArray(lock.usage)
+            ? lock.usage.filter((u) => typeof u === "string" && !!u.trim())
+            : [];
+        if (!scope && usage.length === 0)
+            continue;
+        const system = scope && (await present(root, scope)) ? scope : null;
+        const kept = [];
+        for (const u of usage)
+            if (await present(root, u))
+                kept.push(u);
+        if (!system && kept.length === 0)
+            continue;
+        return { system, usage: kept, from: "lock" };
+    }
+    return null;
+}
 /** Existe como diretório? Um escopo gravado e depois renomeado não pode derrubar o comando. */
 async function present(root, rel) {
     return stat(resolve(root, rel)).then((s) => s.isDirectory(), () => false);
@@ -13,6 +58,19 @@ async function present(root, rel) {
  * comportamento antigo (a raiz).
  */
 export async function measuredScope(root) {
+    const fromLock = await scopeInLock(root);
+    if (fromLock)
+        return fromLock;
+    return censusScope(root);
+}
+/**
+ * O que o CENSO diz sobre onde, sem olhar o lock.
+ *
+ * Quem ESCREVE o lock lê por aqui, e a ordem é o contrário da leitura de propósito: o censo é a
+ * medição fresca que acabou de rodar, e o lock é a cópia da anterior. Ler o lock para escrever o
+ * lock congelaria o primeiro escopo para sempre, e um `--scope` novo nunca chegaria lá.
+ */
+export async function censusScope(root) {
     const raw = await readFile(join(root, "_synthesisui", "census.json"), "utf8").catch(() => null);
     if (!raw)
         return EMPTY;
@@ -61,3 +119,31 @@ export function describeScope(m) {
     ];
     return `read from your census: ${parts.join(" · ")}`;
 }
+/**
+ * GRAVA ONDE ESTE SISTEMA FOI MEDIDO, no ponteiro dele.
+ *
+ * Existe para uma resposta ser dada UMA vez. O escopo se perdeu do servidor em 06/08 e o único
+ * caminho de volta era um `import --scope`, que é um comando fora do vocabulário de quem usa isto -
+ * `connect`, `login`, `doctor`, `sync`, `upgrade` e a skill. Uma mensagem que ensina uma sexta
+ * palavra é pior que mensagem nenhuma: ela transfere para a pessoa um problema que era nosso.
+ *
+ * Silencioso quando não há lock: não é erro, é um repo sem sistema instalado.
+ */
+export async function rememberScope(root, slug, scope, usage) {
+    const path = join(root, "_synthesisui", "ds", slug, ".lock");
+    const raw = await readFile(path, "utf8").catch(() => null);
+    if (!raw)
+        return;
+    let lock;
+    try {
+        lock = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    await writeFile(path, `${JSON.stringify({
+        ...lock,
+        ...(scope ? { scope } : {}),
+        ...(usage.length > 0 ? { usage } : {}),
+    }, null, 2)}\n`, "utf8");
+}

package/package.json

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