synthesisui 0.16.450 → 0.16.455

package/dist/agent-wiring.js

@@ -4,30 +4,20 @@ import { dirname, join } from "node:path";
 import { hasCodexBlock, pinnedInCodex, withCodexBlock } from "./codex-mcp.js";
 import { wrapperSource } from "./statusline-wrapper.js";
 /**
- * QUANDO A CHECAGEM RODA - e por que `Bash` entrou em 12/09.
+ * QUANDO A CHECAGEM RODA - no FIM DO TURNO do agente, desde 23/09.
  *
- * ═══ O QUE O CLIENTE VIA ═══
- *
- * O filtro era `Write|Edit|MultiEdit`, e com isso a garantia inteira dependia de qual ferramenta o
- * agente escolhesse. Medido no `codelevel` em três sessões: toda edição em lote passou por comando
- * de shell e a checagem produziu **0 linhas**; na única edição feita pela ferramenta de edição ela
- * falou na hora, com a regra do sistema nomeada. O produto promete atuar quando ele escreve
- * frontend - não quando o agente segura a caneta certa.
- *
- * Um comando de shell não diz quais arquivos tocou, então quem responde é a árvore de trabalho -
- * ver `changed-files.ts`, onde também está o custo medido.
+ * Ela rodava depois de cada escrita (`PostToolUse`, com o filtro `Write|Edit|MultiEdit|Bash` desde
+ * 12/09, quando se mediu que toda edição em lote do `codelevel` passava por shell). A escolha dele
+ * em 23/09, olhando o ledger do mesmo repositório - 850 execuções, 3 checagens em 303 com achado:
+ * *"no fim de cada turno do agente, sobre o diff"*. O `Stop` não tem filtro: ele roda uma vez por
+ * turno, e quem acha o que o turno escreveu é a árvore de trabalho (`changed-files.ts`), seja qual
+ * for a ferramenta que o agente usou.
  */
-const HOOK_MATCHER = "Write|Edit|MultiEdit|Bash";
-/**
- * O FILTRO QUE ESTE PRODUTO ESCREVIA ANTES DE 12/09 - e a única string que ele se autoriza a
- * alargar.
- *
- * Quem conectou antes disso tem no arquivo dele um filtro que NÓS escrevemos, e deixá-lo como está
- * seria entregar a correção só para quem instala do zero. Alargar um filtro que uma PESSOA
- * escreveu é outra coisa, e continua proibido: a comparação é por igualdade exata com a nossa
- * string antiga, nunca por parecer com ela.
- */
-const HOOK_MATCHER_BEFORE_SHELL = "Write|Edit|MultiEdit";
+const HOOK_EVENT = "Stop";
+/** O evento de ANTES - onde uma instalação anterior a 23/09 tem o nosso hook, e de onde ele sai. */
+const HOOK_EVENT_BEFORE = "PostToolUse";
+/** O NOSSO hook de checagem, e só ele: o `align` da abertura de sessão também diz "synthesisui". */
+const isOurHook = (command) => /\bsynthesisui(@\S+)? hook\b/.test(command ?? "");
 /**
  * Exportado porque a REGRA é uma só: a pasta de uma ferramenta é a evidência de que ela é usada, e
  * a mesma evidência decide o MCP daqui e a casa do bloco em `claude-md.ts`. Duas cópias deste
@@ -111,87 +101,98 @@ export async function alignCommand(root, version) {
 export async function pinnedHookVersion(root) {
     const settings = await readJson(join(root, ".claude", "settings.json")).catch(() => ({}));
     const hooks = (settings.hooks ?? {});
-    const entries = Array.isArray(hooks.PostToolUse) ? hooks.PostToolUse : [];
-    for (const entry of entries)
-        for (const h of entry.hooks ?? []) {
-            const command = h.command ?? "";
-            if (/--no-install synthesisui hook/.test(command))
-                return null;
-            const m = /synthesisui@(\d+\.\d+\.\d+)/.exec(command);
-            if (m)
-                return m[1];
-        }
+    /** O `Stop` primeiro: um projeto no meio da mudança lê a versão de onde o hook roda agora. */
+    for (const event of [HOOK_EVENT, HOOK_EVENT_BEFORE]) {
+        const entries = Array.isArray(hooks[event]) ? hooks[event] : [];
+        for (const entry of entries)
+            for (const h of entry.hooks ?? []) {
+                const command = h.command ?? "";
+                if (!isOurHook(command))
+                    continue;
+                if (/--no-install synthesisui hook/.test(command))
+                    return null;
+                const m = /synthesisui@(\d+\.\d+\.\d+)/.exec(command);
+                if (m)
+                    return m[1];
+            }
+    }
     return null;
 }
 async function wireHook(root, command) {
     const dir = join(root, ".claude");
     const path = join(dir, "settings.json");
     const settings = await readJson(path);
-    const hooks = (settings.hooks ?? {});
-    const post = Array.isArray(hooks.PostToolUse) ? hooks.PostToolUse : [];
+    const hooks = { ...(settings.hooks ?? {}) };
     /**
-     * O CASO QUE ESTA FUNÇÃO NÃO COBRIA, e ele tornava o `connect` uma promessa falsa.
+     * O HOOK DE ANTES SAI, e só ele - E02 da jornada "a checagem no fim do turno".
      *
-     * Ela achava QUALQUER hook contendo "synthesisui" e devolvia "already there" sem olhar a versão -
-     * então um hook pinado nunca subia. Medido em 06/08: o dono rodou `npx synthesisui connect` com o
-     * 0.16.157 e a saída disse `· .claude/settings.json already had it / npx synthesisui@0.16.153 hook`.
-     * O pin era permanente até alguém editar o arquivo à mão, e a mensagem que a gente acabou de escrever
-     * - "rode connect, depois reinicie" - mandava rodar um comando que não fazia a coisa.
-     *
-     * Agora o comando é REESCRITO no lugar quando ele é nosso e difere. O que a idempotência original
-     * protegia continua protegido: o matcher fica como estiver, os hooks vizinhos ficam, e uma segunda
-     * entrada nunca é criada - duas entradas rodariam o verificador duas vezes por escrita.
+     * Um projeto conectado antes de 23/09 tem o nosso hook no `PostToolUse`. Deixá-lo lá rodaria a
+     * checagem duas vezes - por escrita e no fim do turno -, que é o ruído que a mudança existe para
+     * tirar. Sai o NOSSO comando, e nada além: um hook dele na mesma entrada fica, com o filtro que
+     * ele escreveu, e a entrada só some quando fica vazia.
      */
-    const owner = post.find((e) => (e.hooks ?? []).some((h) => (h.command ?? "").includes("synthesisui")));
-    const mine = (owner?.hooks ?? []).find((h) => (h.command ?? "").includes("synthesisui"));
+    let was;
+    const before = Array.isArray(hooks[HOOK_EVENT_BEFORE])
+        ? hooks[HOOK_EVENT_BEFORE]
+        : [];
+    const kept = [];
+    for (const entry of before) {
+        const mine = (entry.hooks ?? []).filter((h) => isOurHook(h.command));
+        if (mine.length === 0) {
+            kept.push(entry);
+            continue;
+        }
+        was = was ?? mine[0]?.command;
+        const theirs = (entry.hooks ?? []).filter((h) => !isOurHook(h.command));
+        if (theirs.length > 0)
+            kept.push({ ...entry, hooks: theirs });
+    }
+    if (was !== undefined) {
+        if (kept.length > 0)
+            hooks[HOOK_EVENT_BEFORE] = kept;
+        else
+            delete hooks[HOOK_EVENT_BEFORE];
+    }
+    const stop = Array.isArray(hooks[HOOK_EVENT]) ? [...hooks[HOOK_EVENT]] : [];
+    const owner = stop.find((e) => (e.hooks ?? []).some((h) => isOurHook(h.command)));
+    const mine = (owner?.hooks ?? []).find((h) => isOurHook(h.command));
+    const save = async () => {
+        await mkdir(dir, { recursive: true });
+        await writeFile(path, `${JSON.stringify({ ...settings, hooks: { ...hooks, [HOOK_EVENT]: stop } }, null, 2)}\n`, "utf8");
+    };
     if (owner && mine) {
-        const was = mine.command ?? "";
-        /**
-         * O FILTRO NOSSO ANTIGO SOBE JUNTO - ver `HOOK_MATCHER_BEFORE_SHELL`.
-         *
-         * Sem isto, a checagem passar a valer para edição por shell alcançaria só quem instalasse do
-         * zero: quem já tinha conectado ficaria com o filtro estreito para sempre, e nada no produto
-         * diria isso a ele.
-         *
-         * **E SÓ QUANDO A ENTRADA É NOSSA INTEIRA** - achado da revisão de contrato no fecho, e a
-         * fronteira estava larga demais. `matcher` vale para TODOS os comandos da entrada: se ele
-         * acrescentou um hook dele ali ao lado - um formatador, um linter -, alargar o filtro passaria
-         * a disparar o comando DELE depois de todo comando de shell, sem ele ter pedido. É a mesma lei
-         * que impede escrever arquivo de um agente que ele não escolheu.
-         */
-        const onlyOurs = (owner.hooks ?? []).every((h) => (h.command ?? "").includes("synthesisui"));
-        const widen = owner.matcher === HOOK_MATCHER_BEFORE_SHELL && onlyOurs;
-        if (widen)
-            owner.matcher = HOOK_MATCHER;
+        const there = mine.command ?? "";
         /**
          * SÓ UM PIN NOSSO É SUBSTITUÍDO, e a fronteira é estreita de propósito.
          *
          * Um comando SEM versão (`npx synthesisui hook`) ou com instalação local é escolha deliberada de
-         * alguém: reescrevê-lo seria pinar a decisão da pessoa, e um spec já protegia isso - o caso do
-         * matcher alargado à mão. O que sobe é `synthesisui@<semver>` para outro semver, que é o único caso
-         * em que "already there" mentia (dono, 06/08: `connect` do 0.16.157 imprimindo
-         * `npx synthesisui@0.16.153 hook` como "already had it").
+         * alguém: reescrevê-lo seria pinar a decisão da pessoa. O que sobe é `synthesisui@<semver>` para
+         * outro semver, que é o único caso em que "already there" mentia (dono, 06/08: `connect` do
+         * 0.16.157 imprimindo `npx synthesisui@0.16.153 hook` como "already had it").
          */
-        const pinnedAt = /synthesisui@(\d+\.\d+\.\d+)/.exec(was)?.[1];
+        const pinnedAt = /synthesisui@(\d+\.\d+\.\d+)/.exec(there)?.[1];
         const proposedAt = /synthesisui@(\d+\.\d+\.\d+)/.exec(command)?.[1];
         const samePin = !pinnedAt || !proposedAt || pinnedAt === proposedAt;
-        if (samePin && !widen)
-            return { status: "already there", command: was || command };
         if (!samePin)
             mine.command = command;
-        await mkdir(dir, { recursive: true });
-        await writeFile(path, `${JSON.stringify({ ...settings, hooks: { ...hooks, PostToolUse: post } }, null, 2)}\n`, "utf8");
-        return samePin
-            ? { status: "updated", command: was || command }
-            : { status: "updated", command, was };
+        if (samePin && was === undefined)
+            return { status: "already there", command: there || command };
+        await save();
+        if (was !== undefined)
+            return { status: "moved", command: mine.command ?? command, was };
+        return { status: "updated", command, was: there };
     }
-    post.push({
-        matcher: HOOK_MATCHER,
-        hooks: [{ type: "command", command }],
-    });
-    await mkdir(dir, { recursive: true });
-    await writeFile(path, `${JSON.stringify({ ...settings, hooks: { ...hooks, PostToolUse: post } }, null, 2)}\n`, "utf8");
-    return { status: "added", command };
+    /**
+     * O COMANDO QUE VAI PARA O FIM DO TURNO. Quem vem do hook de antes leva a escolha que fez lá - um
+     * comando sem versão, ou a instalação local, continua sendo dele. Um pin nosso sobe para esta
+     * versão: o hook pinado antes de 0.16.452 não conhece o `Stop`, e ali ele ficaria mudo.
+     */
+    const carried = was !== undefined && !/synthesisui@\d+\.\d+\.\d+/.test(was) ? was : command;
+    stop.push({ hooks: [{ type: "command", command: carried }] });
+    await save();
+    return was !== undefined
+        ? { status: "moved", command: carried, was }
+        : { status: "added", command };
 }
 /**
  * O MESMO SERVIDOR MCP, NOS CAMINHOS QUE CADA AGENTE LÊ.
@@ -483,9 +484,8 @@ async function wireSessionStart(root, command) {
  */
 export async function hasHook(root) {
     const settings = await readJson(join(root, ".claude", "settings.json")).catch(() => ({}));
-    const post = (settings.hooks ?? {})
-        .PostToolUse;
-    if (!Array.isArray(post))
-        return false;
-    return post.some((e) => (e.hooks ?? []).some((h) => (h.command ?? "").includes("synthesisui")));
+    const hooks = (settings.hooks ?? {});
+    /** Os dois eventos: um projeto que ainda não rodou o `connect` novo continua com a garantia. */
+    return [HOOK_EVENT, HOOK_EVENT_BEFORE].some((event) => Array.isArray(hooks[event]) &&
+        hooks[event].some((e) => (e.hooks ?? []).some((h) => isOurHook(h.command))));
 }

package/dist/auto-sync.js

@@ -0,0 +1,81 @@
+import { spawn } from "node:child_process";
+import { readFile, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * O SYNC NO FIM DO TURNO, COM O SIM DE QUEM INSTALA - E03 da jornada "a checagem no fim do turno".
+ *
+ * A escolha dele em 23/09: *"no fim de cada turno do agente, sobre o diff, fazendo o sync no mesmo
+ * passo"*. A pergunta que a abriu: *"isso agora vai ser automático quando rodar o Synth lá?"*. No
+ * CodeLevel, entre 22/09 e 23/09, 984 linhas do ledger ficaram paradas porque ninguém rodou `sync`,
+ * e o painel dizia que o agente tinha trabalhado menos do que trabalhou.
+ *
+ * ═══ A RESPOSTA É DESTA MÁQUINA, e não do repositório ═══
+ *
+ * `_synthesisui/config.json` é versionado: um sim gravado lá faria o colega que clona o repositório
+ * enviar sem ter sido perguntado. É o mesmo motivo do `.mode` (`mode.ts`): a escolha de uma pessoa
+ * nunca decide por outra. O arquivo mora ao lado, na lista do que o `.gitignore` da pasta cobre.
+ *
+ * ═══ NUNCA PERGUNTADO É NÃO ═══
+ *
+ * Sem o arquivo, nada é enviado - a promessa que o produto fazia até aqui era "nada sai da máquina
+ * sem você rodar um comando", e ela continua valendo para quem não disse sim.
+ */
+export const autoSyncPath = (root) => join(root, "_synthesisui", ".auto-sync");
+export async function readAutoSync(root) {
+    const raw = await readFile(autoSyncPath(root), "utf8").catch(() => null);
+    if (raw == null)
+        return null;
+    const value = raw.trim().toLowerCase();
+    return value === "yes" ? true : value === "no" ? false : null;
+}
+export async function writeAutoSync(root, yes) {
+    await writeFile(autoSyncPath(root), yes ? "yes\n" : "no\n", "utf8");
+}
+/**
+ * QUANTO TEMPO UM SYNC DISPARADO SEGURA O PRÓXIMO.
+ *
+ * Um agente encerra turnos em sequência, às vezes a cada poucos segundos, e cada `sync` relê o
+ * repositório inteiro e fala com o servidor. Dois ao mesmo tempo escreveriam o mesmo cursor
+ * (`.ledger-sent`) e poderiam mandar as mesmas linhas duas vezes. Dois minutos cobrem uma medição
+ * com folga; o que ficar para trás vai no sync seguinte, porque o ledger só anda para frente.
+ *
+ * A LACUNA DECLARADA: o último turno de uma sessão, se cair dentro da janela, só sobe no próximo
+ * sync - numa sessão seguinte, ou quando alguém rodar o comando.
+ */
+export const SYNC_GAP_MS = 2 * 60_000;
+const lockPath = (root) => join(root, "_synthesisui", ".sync-started");
+/**
+ * Dispara o `sync` DESTACADO e volta na hora - o turno do agente não espera a rede.
+ *
+ * O binário é o MESMO que está rodando o hook (`process.argv[1]`): o `npx synthesisui@<v> hook`
+ * pinado resolve para um caminho, e o sync sai daquele caminho, na mesma versão. Um `npx` novo
+ * resolveria outra vez no registro, que é a espera que a instalação local existe para evitar.
+ *
+ * `stdio: "ignore"` também é a razão de ele nunca travar: sem terminal, toda pergunta do `sync`
+ * (`askToOverwrite`, `askForScope`) responde não sozinha.
+ */
+export async function startSync(root) {
+    const last = await stat(lockPath(root)).then((s) => s.mtimeMs, () => 0);
+    if (Date.now() - last < SYNC_GAP_MS)
+        return false;
+    await writeFile(lockPath(root), "", "utf8");
+    const entry = process.argv[1];
+    if (!entry) {
+        await rm(lockPath(root), { force: true });
+        return false;
+    }
+    try {
+        const child = spawn(process.execPath, [entry, "sync"], {
+            cwd: root,
+            detached: true,
+            stdio: "ignore",
+            env: process.env,
+        });
+        child.on?.("error", () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/claude-md.js

@@ -262,8 +262,9 @@ Better than remembering: \`npx synthesisui@latest connect\` installs the check a
 an editor hook, so it runs on its own and this paragraph stops being your job.${VERIFY}`;
 const SELF_CHECK_HOOKED = `
 
-**The check runs by itself.** A hook reports on every file you write, naming the
-token this project already has for anything hardcoded. You do not need to run
+**The check runs by itself.** At the end of every turn, a hook reports on the
+files the turn changed, naming the token this project already has for anything
+hardcoded. You do not need to run
 \`doctor\` by hand, and you should not wait for a final pass.
 
 When it names something, fix it in that file before moving to the next one -

package/dist/commands/add.js

@@ -59,6 +59,18 @@ const IGNORED = [
      * outra"*. Esta lista reconcilia, então quem já está conectado também recebe a linha.
      */
     ".mode",
+    /**
+     * O SIM DELA PARA O ENVIO NO FIM DO TURNO - ver `auto-sync.ts`. Pelo mesmo motivo do `.mode`:
+     * commitado, o sim de uma pessoa enviaria da máquina de todo o time.
+     */
+    ".auto-sync",
+    /** A trava que impede dois syncs ao mesmo tempo - descreve ESTE clone. */
+    ".sync-started",
+    /**
+     * O RELÓGIO DO FIM DO TURNO (`hook.ts`, E01 de 23/09). Ele nasceu fora desta lista, e o primeiro
+     * turno de quem instalasse faria um arquivo nosso aparecer no `git status` dele.
+     */
+    ".turn-clock",
 ];
 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/align.js

@@ -333,7 +333,7 @@ opts = {}) {
      */
     if (folderBehind && hookBehind && folderBehind === hookBehind)
         out.push({
-            says: `you are running CLI ${cli} and two things here are still on ${folderBehind}: the files under _synthesisui/ds/${lock.slug}, and the check that runs after every write - so your agent's edits are read by the older one.`,
+            says: `you are running CLI ${cli} and two things here are still on ${folderBehind}: the files under _synthesisui/ds/${lock.slug}, and the check that runs at the end of each agent turn - so your agent's work is read by the older one.`,
             run: "npx synthesisui upgrade",
         });
     else {
@@ -344,7 +344,7 @@ opts = {}) {
             });
         if (hookBehind)
             out.push({
-                says: `the check that runs after every write is pinned to CLI ${hookBehind} and you are running ${cli} - your agent's edits are being checked by an older reader than the one measuring this repo.`,
+                says: `the check that runs at the end of each agent turn is pinned to CLI ${hookBehind} and you are running ${cli} - your agent's work is being checked by an older reader than the one measuring this repo.`,
                 run: "npx synthesisui upgrade",
             });
     }

package/dist/commands/connect.js

@@ -2,6 +2,7 @@ import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { codexPinBefore, exists, wireAgent } from "../agent-wiring.js";
 import { AGENTS, chooseAgents, filesOf, rememberChoice, } from "../agents-chosen.js";
+import { readAutoSync, writeAutoSync } from "../auto-sync.js";
 import { blockHomes, syncClaudeMd } from "../claude-md.js";
 import { resolveRegistry } from "../config.js";
 import { guaranteeIfNew } from "../guarantee.js";
@@ -25,7 +26,7 @@ import { installedSlugs } from "./sync.js";
  * of them and got, instead, the CLAUDE.md instruction we had already measured
  * being ignored.
  *
- *   hook   guarantees   runs after every write, whether the agent likes it or not
+ *   hook   guarantees   runs at the end of every agent turn, whether the agent likes it or not
  *   mcp    audits       lets the agent ask the system instead of guessing
  *   md     informs      and now stops repeating what the hook already ensures
  *
@@ -451,18 +452,50 @@ export async function connect(opts) {
      * de duas frases que a etapa 11 fechou no `template`, aparecendo na tela que a 12 acabou de
      * escrever - e `wired.hook` diz `skipped`, então a informação para suprimir já estava aqui.
      */
+    /**
+     * O CODEX NÃO TEM FIM DE TURNO QUE SE SEGURE - E02 da jornada "a checagem no fim do turno". A
+     * checagem mora no `Stop` do Claude Code; num repositório que escolheu só o Codex ela não existe,
+     * e a tela diz isso em vez de deixar ele supor que o agente dele está coberto.
+     */
+    if (want.hook && wired.hook === "skipped" && chosen.agents.includes("codex"))
+        /** `true`: é aviso, não estado - uma linha "já estava lá" some no resumo, e esta não pode. */
+        row(true, say("· Codex has no end-of-turn hook we can hold - run `npx synthesisui doctor` to check what it wrote"));
+    /**
+     * O ENVIO NO FIM DO TURNO, PERGUNTADO UMA VEZ - E03 da jornada "a checagem no fim do turno".
+     *
+     * A pergunta existe porque a promessa mudou: até aqui, nada saía da máquina dele sem ele rodar um
+     * comando. Quem diz sim passa a ter o painel em dia sozinho; quem diz não - ou quem nunca foi
+     * perguntado, como um CI - continua exatamente como antes. A resposta mora em `.auto-sync`, fora do
+     * git (ver `auto-sync.ts`), e com ela gravada a pergunta não volta.
+     */
+    if (want.hook && wired.hook !== "skipped") {
+        const before = await readAutoSync(root).catch(() => null);
+        const now = before ?? (await askToSendAtTurnEnd());
+        if (before === null && now !== null)
+            await writeAutoSync(root, now);
+        row(before === null, now === true
+            ? say("✓ what the check records is sent to your dashboard at the end of each turn")
+            : say("· what the check records stays on this machine - run `npx synthesisui sync` to send it"));
+    }
     if (want.hook && wired.hook !== "skipped") {
         row(wired.hook !== "already there", (() => {
             return wired.hook === "added"
-                ? say("✓ .claude/settings.json  the check now runs after every write")
-                : wired.hook === "updated"
+                ? say("✓ .claude/settings.json  the check now runs at the end of each agent turn")
+                : wired.hook === "moved"
                     ? /**
-                       * A LINHA QUE FALTAVA, e a ausência dela fazia o comando mentir: rodando o 0.16.157, a
-                       * saída dizia "already had it" e imprimia `npx synthesisui@0.16.153 hook` embaixo
-                       * (dono, 06/08). Quem lê "already had it" fecha o terminal.
+                       * A CHECAGEM MUDOU DE LUGAR, dita como mudança - E02 da jornada "a checagem no fim do
+                       * turno". Quem tinha o hook por escrita precisa saber que ele não roda mais ali, ou vai
+                       * estranhar o silêncio no meio do turno.
                        */
-                        `✓ .claude/settings.json  the check moved from ${wired.was?.match(/synthesisui@(\d+\.\d+\.\d+)/)?.[1] ?? "an older version"} to this one`
-                    : say("· .claude/settings.json  already had it");
+                        say("✓ .claude/settings.json  the check moved from every write to the end of each agent turn")
+                    : wired.hook === "updated"
+                        ? /**
+                           * A LINHA QUE FALTAVA, e a ausência dela fazia o comando mentir: rodando o 0.16.157, a
+                           * saída dizia "already had it" e imprimia `npx synthesisui@0.16.153 hook` embaixo
+                           * (dono, 06/08). Quem lê "already had it" fecha o terminal.
+                           */
+                            `✓ .claude/settings.json  the check moved from ${wired.was?.match(/synthesisui@(\d+\.\d+\.\d+)/)?.[1] ?? "an older version"} to this one`
+                        : say("· .claude/settings.json  already had it");
         })(), wired.command);
         /**
          * A SEGUNDA COSTURA, dita por nome. As onze ferramentas MCP são PULL e o hook de escrita roda
@@ -677,7 +710,7 @@ export async function connect(opts) {
          * interrompido precisa saber que só apagar a região para isso.
          */
         if (entries.includes(".claude/settings.json"))
-            console.log(body(paint.faint(say("    the write check inside it keeps running until that entry is gone"))));
+            console.log(body(paint.faint(say("    the turn check inside it keeps running until that entry is gone"))));
     }
     /**
      * O CURSOR SAIU DO PRODUTO (A6 da etapa 12), e quem tem os arquivos dele é avisado com os
@@ -760,7 +793,7 @@ export async function connect(opts) {
      * Um pedido que aparece sempre é um pedido que a pessoa passa a ignorar - e aí ele não serve para
      * a vez em que era mesmo obrigatório.
      */
-    const moved = (s) => s === "added" || s === "updated";
+    const moved = (s) => s === "added" || s === "updated" || s === "moved";
     const needsRestart = moved(wired.hook) ||
         moved(wired.session) ||
         (Array.isArray(wired.mcp) && wired.mcp.some((m) => moved(m.status)));
@@ -778,7 +811,7 @@ export async function connect(opts) {
         ...(bothChecks
             ? [say("the checks")]
             : moved(wired.hook)
-                ? [say("the write check")]
+                ? [say("the turn check")]
                 : moved(wired.session)
                     ? [say("the session check")]
                     : []),
@@ -825,8 +858,30 @@ export async function connect(opts) {
          * `apps/web/src/lib/cli/commands.spec.ts`.
          */
         console.log("");
-        console.log(bodyWrapped(say("The hook resolves against the npm registry on each edit - that is the wait, not the check. Add synthesisui to your devDependencies and run this again; it switches by itself to local, several times faster."))
+        console.log(bodyWrapped(say("The hook resolves against the npm registry at the end of each turn - that is the wait, not the check. Add synthesisui to your devDependencies and run this again; it switches by itself to local, several times faster."))
             .map(paint.dim)
             .join("\n"));
     }
 }
+/**
+ * Pergunta uma vez, e só num terminal de verdade - o mesmo molde do `askToOverwrite` do `sync`.
+ *
+ * Sem TTY devolve `null`: não há quem responder, e nada é gravado. O padrão do terminal é NÃO
+ * (`[y/N]`), porque enviar é a mudança, e uma mudança de promessa pede um sim dito.
+ */
+async function askToSendAtTurnEnd() {
+    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(`  ${say("send what the check records to your dashboard at the end of each turn?")} [y/N]: `);
+        return /^(y(es)?|s(im)?)$/i.test(answer.trim());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/hook.js

@@ -1,10 +1,12 @@
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
+import { readAutoSync, startSync } from "../auto-sync.js";
 import { changedSince } from "../changed-files.js";
-import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
+import { emptyTally, exportedNames, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
 import { checkContracts } from "../doctor/contract-check.js";
 import { appendEvent, ledgerPath } from "../doctor/ledger.js";
 import { diagnose, nameToWrite, scanSource } from "../doctor/scan.js";
+import { declarados, falaDaPrateleira, naPrateleira } from "../doctor/shelf.js";
 import { governs, ungovernedIn } from "../governed.js";
 import { readMode } from "../mode.js";
 import { namesRemoved, previousText, rulesTouchedBy, } from "../rule-touched.js";
@@ -76,6 +78,16 @@ const clockOf = async (root) => stat(ledgerPath(root)).then((s) => s.mtimeMs, ()
  * que o produto acabou de ser instalado - e a tela do `connect` já disse que ele está vivo.
  */
 const startClock = (root) => writeFile(ledgerPath(root), "", { flag: "a" }).catch(() => { });
+/**
+ * O RELÓGIO DO TURNO É PRÓPRIO, e não o do ledger - E01 da jornada "a checagem no fim do turno".
+ *
+ * O ledger anda a cada comando que escreve nele: um `doctor`, um `align` ou o próprio MCP no MEIO
+ * do turno moveriam o relógio, e o fim do turno deixaria de ver tudo o que foi escrito antes
+ * deles. Um arquivo só deste relógio anda uma vez por turno, no fim, depois de olhar.
+ */
+const TURN_CLOCK = "_synthesisui/.turn-clock";
+const turnClockOf = (root) => stat(join(root, TURN_CLOCK)).then((s) => s.mtimeMs, () => 0);
+const moveTurnClock = (root) => writeFile(join(root, TURN_CLOCK), "", "utf8").catch(() => { });
 /**
  * QUANTOS ARQUIVOS UM COMANDO DE SHELL PODE FAZER O PRODUTO RELATAR DE UMA VEZ.
  *
@@ -122,7 +134,7 @@ async function greet(root, rel) {
     return [
         `${rel} - checked, nothing to name. Every value in it has a token.`,
         "",
-        "That check now runs on every file you write, by itself. Tell the person once",
+        "That check now runs at the end of every turn, by itself. Tell the person once",
         "that it is live, so they know it installed, and then stop mentioning it - from",
         "here it only speaks when something needs a name.",
     ].join("\n");
@@ -361,7 +373,14 @@ async function report(root, filePath, mode) {
      * parte do relatório que RECUSA, e uma recusa escondida embaixo de uma lista de valores é uma
      * recusa que ninguém lê.
      */
+    /**
+     * A PRATELEIRA VEM ANTES DOS VALORES, e a ordem é o ponto: trocar um hex por
+     * um token num componente que não precisava existir é polir o que devia ser
+     * apagado. Se a peça já está no sistema, essa é a primeira coisa a saber.
+     */
+    const prateleira = falaDaPrateleira(rel, naPrateleira(exportedNames(src), declarados(documents)), table.name ?? table.slug ?? "this system");
     const lines = [
+        ...(prateleira.length > 0 ? [...prateleira, ""] : []),
         ...(composed.length > 0 ? [...composed, ""] : []),
         ...(broke.length > 0 ? [...broke, ""] : []),
         `${rel} - checked against ${table.name ?? table.slug}.`,
@@ -417,6 +436,10 @@ export async function hook(opts) {
         process.stdout.write(`${JSON.stringify(pass())}\n`);
         return;
     }
+    if (input.hook_event_name === "Stop") {
+        await endOfTurn(root, input);
+        return;
+    }
     if (input.hook_event_name !== "PostToolUse") {
         process.stdout.write(`${JSON.stringify(pass())}\n`);
         return;
@@ -456,6 +479,23 @@ export async function hook(opts) {
         process.stdout.write(`${JSON.stringify(pass())}\n`);
         return;
     }
+    const { said, block } = await checkChanged(root, changed, mode, "command");
+    /**
+     * E O RELÓGIO ANDA AQUI, depois de olhar - `appendEvent` já o moveu para cada arquivo relatado,
+     * e esta linha cobre o caso em que todos os relatórios falharam na leitura.
+     */
+    await startClock(root);
+    const context = said.join("\n\n");
+    process.stdout.write(`${JSON.stringify(said.length === 0 ? pass() : block ? refuse(context) : speak(context))}\n`);
+}
+/**
+ * O QUE A RODADA MUDOU, CHECADO - o corpo que era só do caminho de shell, e que agora o fim do turno
+ * também usa. Os dois fazem a mesma pergunta ("o que foi escrito desde a última vez que olhei?"),
+ * e duas cópias da resposta divergiriam no primeiro conserto.
+ */
+async function checkChanged(root, changed, mode, 
+/** O que a pessoa chama de rodada: o comando de shell, ou o turno inteiro do agente. */
+round) {
     const said = [];
     /**
      * UMA RECUSA EM QUALQUER ARQUIVO DA RODADA RECUSA A RODADA - e é o lado certo: um comando de
@@ -518,17 +558,61 @@ export async function hook(opts) {
     }
     if (rest.length > 0)
         said.push([
-            `${rest.length} more file${rest.length === 1 ? "" : "s"} changed in this command and ${rest.length === 1 ? "was" : "were"} not checked here: ${rest
+            `${rest.length} more file${rest.length === 1 ? "" : "s"} changed in this ${round} and ${rest.length === 1 ? "was" : "were"} not checked here: ${rest
                 .slice(0, 10)
                 .map((c) => c.rel)
                 .join(", ")}${rest.length > 10 ? `, +${rest.length - 10} more` : ""}.`,
-            "Run `npx synthesisui doctor` to see them, or write one of them again and this will check it.",
+            round === "turn"
+                ? "Run `npx synthesisui doctor` to see them - they are checked again the next turn one of them changes."
+                : "Run `npx synthesisui doctor` to see them, or write one of them again and this will check it.",
         ].join("\n"));
+    return { said, block };
+}
+/**
+ * O FIM DO TURNO - E01 da jornada "a checagem no fim do turno", escolha dele em 23/09: *"no fim de
+ * cada turno do agente, sobre o diff"*.
+ *
+ * UMA VOZ SÓ, E ELA SEGURA O TURNO. No `Stop`, a única saída que chega ao agente é `decision:
+ * "block"` com o motivo: o Claude Code devolve o motivo ao agente, e ele continua trabalhando em vez
+ * de encerrar. É o momento que a checagem por escrita não tinha - tudo o que o turno escreveu, numa
+ * mensagem só, antes de a resposta sair.
+ *
+ * E SEGURA UMA VEZ. Quando o turno já foi segurado, o Claude Code manda `stop_hook_active: true`, e
+ * este hook passa sem olhar. Sem isso, uma cor antiga que continua no arquivo - as do Hero do
+ * CodeLevel, medidas em 23/09 - prenderia o agente num laço que só a pessoa quebra.
+ *
+ * O RELÓGIO NÃO ANDA NESSA PASSAGEM, de propósito: o que o agente mudou para responder ao motivo
+ * fica mais novo que o relógio, e o próximo turno de verdade o checa. É assim que o ledger ganha a
+ * linha limpa que prova o conserto.
+ */
+async function endOfTurn(root, input) {
     /**
-     * E O RELÓGIO ANDA AQUI, depois de olhar - `appendEvent` já o moveu para cada arquivo relatado,
-     * e esta linha cobre o caso em que todos os relatórios falharam na leitura.
+     * O SYNC, QUANDO ELA DISSE SIM - E03. Disparado antes de qualquer resposta e sem esperar: o turno
+     * não fica mais lento por causa da rede, e um sync que falha não custa a checagem. Sem o sim, esta
+     * linha não chega a tocar em rede nenhuma (ver `auto-sync.ts`).
      */
-    await startClock(root);
-    const context = said.join("\n\n");
-    process.stdout.write(`${JSON.stringify(said.length === 0 ? pass() : block ? refuse(context) : speak(context))}\n`);
+    if ((await readAutoSync(root).catch(() => null)) === true)
+        await startSync(root).catch(() => false);
+    const out = (frame) => process.stdout.write(`${JSON.stringify(frame)}\n`);
+    if (input.stop_hook_active) {
+        out(pass());
+        return;
+    }
+    const clock = await turnClockOf(root);
+    /** Ver `startClock`: o primeiro fim de turno depois de instalado acerta o relógio e cala. */
+    if (clock === 0) {
+        await moveTurnClock(root);
+        out(pass());
+        return;
+    }
+    const ungoverned = await ungovernedIn(root);
+    const mode = await readMode(root).catch(() => null);
+    const changed = await changedSince(root, clock, (rel) => governs(rel, ungoverned)).catch(() => []);
+    const { said } = changed.length > 0
+        ? await checkChanged(root, changed, mode, "turn")
+        : { said: [] };
+    await moveTurnClock(root);
+    out(said.length === 0
+        ? pass()
+        : { decision: "block", reason: said.join("\n\n") });
 }

package/dist/commands/upgrade.js

@@ -171,7 +171,7 @@ async function rewireIfBehind(root, cli) {
         mcp: true,
         agents: await agentsToMaintain(root),
     }).catch(() => null);
-    console.log(`↻ the check after every write moved from ${pinned} to ${cli}`);
+    console.log(`↻ the end-of-turn check moved from ${pinned} to ${cli}`);
     console.log("  Reopen your editor session - hooks are read at startup.");
 }
 /**

package/dist/copy/connect.pt-BR.js

@@ -32,7 +32,12 @@ register("pt-BR", {
     // ── o estado do repositório ──
     "· no design system installed here yet - the agent has no index, and memory has nothing to belong to.": "· nenhum design system instalado aqui ainda - o agente não tem índice, e a memória não tem a que pertencer.",
     // ── a fiação do agente ──
-    "✓ .claude/settings.json  the check now runs after every write": "✓ .claude/settings.json  a verificação roda após cada escrita",
+    "✓ .claude/settings.json  the check now runs at the end of each agent turn": "✓ .claude/settings.json  a verificação roda no fim de cada turno do agente",
+    "✓ .claude/settings.json  the check moved from every write to the end of each agent turn": "✓ .claude/settings.json  a verificação saiu de cada escrita e foi para o fim de cada turno do agente",
+    "✓ what the check records is sent to your dashboard at the end of each turn": "✓ o que a verificação registra vai para o seu painel no fim de cada turno",
+    "· what the check records stays on this machine - run `npx synthesisui sync` to send it": "· o que a verificação registra fica nesta máquina - rode `npx synthesisui sync` para enviar",
+    "send what the check records to your dashboard at the end of each turn?": "enviar o que a verificação registra para o seu painel no fim de cada turno?",
+    "· Codex has no end-of-turn hook we can hold - run `npx synthesisui doctor` to check what it wrote": "· o Codex não tem um fim de turno que a gente possa segurar - rode `npx synthesisui doctor` para checar o que ele escreveu",
     "· .claude/settings.json  already had it": "· .claude/settings.json  já estava lá",
     "✓ .claude/settings.json  each session opens with what is missing": "✓ .claude/settings.json  cada sessão abre com o que falta",
     "✓ .claude/settings.json  the session check moved to this one": "✓ .claude/settings.json  a verificação de sessão veio para esta",
@@ -53,7 +58,7 @@ register("pt-BR", {
     "Selected: {agents}": "Selecionados: {agents}",
     "    our part in {files} sits between `synthesisui:start` and `synthesisui:end` - the rest of each file is yours": "    a nossa parte em {files} fica entre `synthesisui:start` e `synthesisui:end` - o resto de cada arquivo é seu",
     "    in {files} only our `synthesisui` entry is ours - the rest of the file is yours": "    em {files} só a nossa entrada `synthesisui` é nossa - o resto do arquivo é seu",
-    "    the write check inside it keeps running until that entry is gone": "    a verificação de escrita dentro dele continua rodando até aquela entrada sair",
+    "    the turn check inside it keeps running until that entry is gone": "    a verificação do fim do turno dentro dele continua rodando até aquela entrada sair",
     "    the rules file is ours to delete; in `.cursor/mcp.json` only the `synthesisui` entry is - the other servers there are yours": "    o arquivo de regras é nosso para apagar; no `.cursor/mcp.json` só a entrada `synthesisui` é - os outros servidores ali são seus",
     "· not an agent this CLI knows: {names}": "· não é um agente que este CLI conhece: {names}",
     "· no agent chosen, and nothing here says which agent you use - run with `--agents claude` or `--agents codex`, or run this in a terminal to pick from the list": "· nenhum agente escolhido, e nada aqui diz qual agente você usa - rode com `--agents claude` ou `--agents codex`, ou rode isto num terminal para escolher da lista",
@@ -117,12 +122,12 @@ register("pt-BR", {
     "then, to pick up where you left off:": "e depois, para voltar de onde você parou:",
     // ── os nomes do que moveu, usados dentro da frase acima ──
     "the checks": "as verificações",
-    "the write check": "a verificação de escrita",
+    "the turn check": "a verificação do fim do turno",
     "the session check": "a verificação de sessão",
     "the tools": "as ferramentas",
     "the skills": "as skills",
     // ── o custo do hook ──
-    "The hook resolves against the npm registry on each edit - that is the wait, not the check. Add synthesisui to your devDependencies and run this again; it switches by itself to local, several times faster.": "O hook resolve no registro do npm a cada edição - a espera é isso, não a verificação. Adicione synthesisui às suas devDependencies e rode isto de novo; ele passa a resolver local sozinho, várias vezes mais rápido.",
+    "The hook resolves against the npm registry at the end of each turn - that is the wait, not the check. Add synthesisui to your devDependencies and run this again; it switches by itself to local, several times faster.": "O hook resolve no registro do npm no fim de cada turno - a espera é isso, não a verificação. Adicione synthesisui às suas devDependencies e rode isto de novo; ele passa a resolver local sozinho, várias vezes mais rápido.",
     // ── até onde a garantia vai (uma vez, e de novo só quando a resposta muda) ──
     "How far this check goes here": "Até onde esta verificação vai aqui",
     "Every file this project writes is checked as it is written - by an edit tool or by a shell command, it makes no difference.": "Todo arquivo que este projeto escreve é verificado no momento da escrita - por uma ferramenta de edição ou por um comando de shell, dá no mesmo.",
@@ -130,8 +135,8 @@ register("pt-BR", {
     "What a file no longer has is measured against your last commit. A file git has never seen has no before, so nothing is reported as removed there.": "O que um arquivo deixou de ter é medido contra o seu último commit. Um arquivo que o git nunca viu não tem um antes, então nada é reportado como removido nele.",
     "A value counts as coming from your system in two spellings: `var(--token)`, and the {n} utility names your own theme generates - `bg-primary`, `p-6`, `rounded-lg`.": "Um valor conta como vindo do seu sistema em duas grafias: `var(--token)`, e os {n} nomes de utility que o seu próprio tema gera - `bg-primary`, `p-6`, `rounded-lg`.",
     "A value counts as coming from your system when it is written as `var(--token)`. This system declares no theme names, so a utility class is not read as a reference to it.": "Um valor conta como vindo do seu sistema quando é escrito como `var(--token)`. Este sistema não declara nomes de tema, então uma classe utility não é lida como referência a ele.",
-    "Every file in this project is checked as you write it, except {out}, which you named under `ungoverned` in `_synthesisui/config.json`.": "Todo arquivo deste projeto é verificado no momento em que você o escreve, menos {out}, que você escreveu em `ungoverned` no `_synthesisui/config.json`.",
-    "Every file in this project is checked as you write it. To leave a place out, name it under `ungoverned` in `_synthesisui/config.json`.": "Todo arquivo deste projeto é verificado no momento em que você o escreve. Para deixar um lugar de fora, escreva-o em `ungoverned` no `_synthesisui/config.json`.",
+    "Every file in this project is checked at the end of each agent turn, except {out}, which you named under `ungoverned` in `_synthesisui/config.json`.": "Todo arquivo deste projeto é verificado no fim de cada turno do agente, menos {out}, que você escreveu em `ungoverned` no `_synthesisui/config.json`.",
+    "Every file in this project is checked at the end of each agent turn. To leave a place out, name it under `ungoverned` in `_synthesisui/config.json`.": "Todo arquivo deste projeto é verificado no fim de cada turno do agente. Para deixar um lugar de fora, escreva-o em `ungoverned` no `_synthesisui/config.json`.",
     "What this system knows was read from {scope}. {apps} declare a dependency on `{specifier}`, so they write in its vocabulary - nothing in them was read.": "O que este sistema sabe foi lido de {scope}. {apps} declaram dependência de `{specifier}`, então escrevem no vocabulário dele - nada dentro deles foi lido.",
     "What this system knows was read from {scope} - nothing outside it was opened.": "O que este sistema sabe foi lido de {scope} - nada fora dali foi aberto.",
     "A value this ruler cannot read is not a value it approved - silence here is never a pass.": "Um valor que esta régua não consegue ler não é um valor que ela aprovou - silêncio aqui nunca é aprovação.",

package/dist/doctor/components-scan.js

@@ -274,6 +274,40 @@ function importedNames(source, internal = []) {
  */
 const BOUND = /(?:const|let|var|function|class)\s+([A-Z][A-Za-z0-9_]*)|[{,]\s*\w+\s*:\s*([A-Z][A-Za-z0-9_]*)\s*(?:=[^,}]*)?\s*[,}]/g;
 const EXPORTED_NAME = /export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var)\s+([A-Z][A-Za-z0-9_]*)|export\s+default\s+([A-Z][A-Za-z0-9_]*)|export\s*\{([^}]*)\}/g;
+/**
+ * OS COMPONENTES QUE ESTE ARQUIVO EXPORTA - a metade que faltava para o hook
+ * enxergar a PRATELEIRA, e não só os valores.
+ *
+ * O hook já dizia "este valor tem nome no sistema". Ele nunca dizia "esta PEÇA
+ * tem recipe no sistema", e o agente do CodeLevel mediu o efeito disso em
+ * 22/09: escreveu cinco componentes do zero num dia, com pelo menos quatro
+ * deles já existindo no índice - *"a ferramenta estava ligada o dia inteiro e
+ * eu não fiz uma pergunta a ela"*.
+ *
+ * Reusa a mesma regex de `localOnlyNames`, que é quem já sabe ler as quatro
+ * formas de exportar. Duas leituras do mesmo formato discordariam um dia.
+ */
+export function exportedNames(source) {
+    const nomes = new Set();
+    EXPORTED_NAME.lastIndex = 0;
+    for (const m of source.matchAll(EXPORTED_NAME)) {
+        if (m[1])
+            nomes.add(m[1]);
+        if (m[2])
+            nomes.add(m[2]);
+        if (m[3]) {
+            for (const cru of m[3].split(",")) {
+                const nome = cru
+                    .trim()
+                    .split(/\s+as\s+/)[0]
+                    ?.trim();
+                if (nome && /^[A-Z]/.test(nome))
+                    nomes.add(nome);
+            }
+        }
+    }
+    return nomes;
+}
 export function localOnlyNames(source) {
     const exported = new Set();
     EXPORTED_NAME.lastIndex = 0;

package/dist/doctor/shelf.js

@@ -0,0 +1,91 @@
+/**
+ * A PRATELEIRA - "esta peça já existe no sistema", dito sem ninguém perguntar.
+ *
+ * O PROBLEMA, medido em 22/09 no CodeLevel. O agente escreveu cinco componentes
+ * do zero num dia; pelo menos quatro já existiam no índice do sistema. Ele
+ * mesmo contou o porquê: *"o AGENTS.md manda consultar o índice antes de
+ * escrever UI (...) não consultei uma única vez. Também não chamei nenhuma das
+ * ferramentas dele"*. E fechou: *"a ferramenta estava ligada o dia inteiro e eu
+ * não fiz uma pergunta a ela"*.
+ *
+ * As duas metades do produto têm caminhos diferentes, e é isso que explica o
+ * resultado: a GUARDA roda no hook, sem pedir licença, e funcionou 209 de 209.
+ * A BIBLIOTECA é MCP - `list_components`, `describe_component` -, e MCP é PULL:
+ * só acontece se o agente resolver perguntar. Ele não resolveu nenhuma vez.
+ *
+ * Isto põe a biblioteca no caminho de push.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * A DISCIPLINA, e ela é a parte importante deste arquivo.
+ *
+ * Casar NOME é a família de defeito que este repositório já pagou caro: nome
+ * vencendo a leitura foi o erro do importador. Então aqui:
+ *
+ *   IGUALDADE EXATA, depois de normalizar. Nada de substring, prefixo,
+ *   distância de edição ou plural. `Card` casa com `card`; `CardHeader` não
+ *   casa com `card`, e é melhor perder o aviso do que dar um errado.
+ *
+ *   É PERGUNTA, NUNCA VEREDITO. O texto não diz "você errou": diz que os dois
+ *   nomes coincidem e pergunta se são a mesma coisa.
+ *
+ *   A CHECAGEM DECLARA A PRÓPRIA FRAQUEZA na saída. Quem lê é um agente, e um
+ *   agente que recebe "isto já existe" como fato vai apagar trabalho certo.
+ */
+/** `StatCard` → `stat-card`; `DSCard` → `ds-card`. */
+export function normalizar(nome) {
+    return nome
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .toLowerCase();
+}
+/** Os componentes que o sistema declara, de um documento de design system. */
+export function declarados(documents) {
+    const nomes = new Set();
+    for (const doc of documents) {
+        const comps = doc?.components;
+        if (comps)
+            for (const k of Object.keys(comps))
+                nomes.add(normalizar(k));
+        const blocos = doc?.blocks;
+        if (blocos)
+            for (const k of Object.keys(blocos))
+                nomes.add(normalizar(k));
+    }
+    return nomes;
+}
+/**
+ * O que este arquivo define E o sistema já declara. Vazio é a resposta normal.
+ *
+ * `ds-` some do nome declarado antes de comparar: o sistema guarda `card` e a
+ * classe emitida é `ds-card`, e um repositório que chama a peça dele de `DsCard`
+ * está falando do mesmo componente.
+ */
+export function naPrateleira(exportados, sistema) {
+    const achados = [];
+    for (const nome of exportados) {
+        const n = normalizar(nome);
+        const semPrefixo = n.startsWith("ds-") ? n.slice(3) : n;
+        if (sistema.has(n))
+            achados.push({ escrito: nome, declarado: n });
+        else if (sistema.has(semPrefixo))
+            achados.push({ escrito: nome, declarado: semPrefixo });
+    }
+    return achados;
+}
+/** O texto que o agente lê. Pergunta, com a fraqueza declarada. */
+export function falaDaPrateleira(rel, achados, sistema) {
+    if (achados.length === 0)
+        return [];
+    return [
+        `${rel} - ${sistema} already declares ${achados.length === 1 ? "a component" : "components"} with ${achados.length === 1 ? "this name" : "these names"}:`,
+        ...achados.map((a) => `  you wrote ${a.escrito}  ·  the system has ${a.declarado}`),
+        "",
+        "If they are the same thing, materialize the system's instead of keeping yours - it arrives already wearing the tokens, and it stays in step when the system changes.",
+        /**
+         * A FRAQUEZA VAI JUNTO. Esta checagem compara NOME, e nome colide: um
+         * `Card` de dashboard e um `card` de baralho são palavras iguais e coisas
+         * diferentes. Sem esta linha, um agente obediente apaga trabalho certo.
+         */
+        "This check compares NAMES only, and names collide. If yours is a different thing, keep it and say so in your summary.",
+    ];
+}

package/dist/guarantee.js

@@ -120,10 +120,10 @@ system) {
      */
     lines.push(out.length > 0
         ? {
-            text: "Every file in this project is checked as you write it, except {out}, which you named under `ungoverned` in `_synthesisui/config.json`.",
+            text: "Every file in this project is checked at the end of each agent turn, except {out}, which you named under `ungoverned` in `_synthesisui/config.json`.",
             values: { out: out.map((p) => `\`${p}\``).join(", ") },
         }
-        : plain("Every file in this project is checked as you write it. To leave a place out, name it under `ungoverned` in `_synthesisui/config.json`."));
+        : plain("Every file in this project is checked at the end of each agent turn. To leave a place out, name it under `ungoverned` in `_synthesisui/config.json`."));
     /**
      * E DE ONDE O SISTEMA FOI LIDO - outra pergunta, e por isso outra frase.
      *

package/dist/install-marks.js

@@ -235,7 +235,24 @@
  * chama `wireAgent`, então rodar o comando é o caminho de volta - e ele só alarga a string que era
  * nossa, nunca um filtro que uma pessoa escreveu.
  */
-export const MATERIALISER_SINCE = "0.16.429";
+/**
+ * 0.16.429 -> 0.16.453 em 23/09, e o passo 1 dá **SIM**: muda um byte que cai no `.claude/settings.json`
+ * dele. O hook sai do `PostToolUse` e vai para o `Stop` - a checagem passa a rodar no fim do turno do
+ * agente (E02 da jornada "a checagem no fim do turno"). Quem conectou antes tem o hook por escrita, e
+ * sem rodar o comando fica nele: a checagem continua a cada arquivo, e o fim do turno nunca é
+ * checado. É o mesmo caso de 12/09 acima: o `upgrade` chama `wireAgent`, e rodá-lo é o caminho.
+ */
+/**
+ * 0.16.453 -> 0.16.454, ainda em 23/09, e o passo 1 dá **SIM** outra vez: o `.gitignore` da pasta dele
+ * ganha `.auto-sync`, `.sync-started` e `.turn-clock` (E03). Sem o comando, o relógio do fim do turno
+ * aparece no `git status` dele no primeiro turno - um arquivo nosso que ele commitaria por engano.
+ */
+/**
+ * 0.16.454 -> 0.16.455, ainda em 23/09, e o passo 1 dá **SIM**: o bloco gerenciado do `CLAUDE.md` dele
+ * dizia que o hook "reports on every file you write" - a instrução que o agente dele lê sobre o próprio
+ * mecanismo. Passa a dizer o fim do turno (E04), e só o `upgrade` reescreve o bloco.
+ */
+export const MATERIALISER_SINCE = "0.16.455";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *
@@ -366,7 +383,14 @@ export const COUNTED_DIFFERENTLY = "this run counts a value as named only when Y
  * utility, um arquivo escrito inteiro no vocabulário do sistema recebia zero. A contagem em si é a
  * outra marca - ver `COUNTED_DIFFERENTLY_SINCE`, que sobe no mesmo diff.
  */
-export const CHECKER_SINCE = "0.16.424";
+/**
+ * 0.16.424 -> 0.16.454 em 23/09, e o passo 1 dá **SIM**: o hook passa a disparar o `sync` no fim do
+ * turno quando ela disse sim no `connect` (E03 da jornada "a checagem no fim do turno"). Um hook
+ * anterior - uma instalação local mais velha que o `connect` que fez a pergunta - lê o mesmo arquivo
+ * e não faz nada com ele: o painel continuaria atrasado com o sim dado. É o interruptor que parece
+ * ligado e não está, o mesmo caso do CONSUMIR em 12/09.
+ */
+export const CHECKER_SINCE = "0.16.454";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *

package/dist/report-insight.js

@@ -158,7 +158,7 @@ export function oQueMuda(c) {
     const aMao = observados.filter((v) => !v.token);
     if (aMao.length === 0)
         return [
-            "Every design value in your code already comes from a token you declare. What SynthesisUI adds here is keeping it that way: the check runs after every file your agent writes, and a value that drifts off your own scale comes back to you as a decision instead of landing silently.",
+            "Every design value in your code already comes from a token you declare. What SynthesisUI adds here is keeping it that way: the check runs at the end of every agent turn, and a value that drifts off your own scale comes back to you as a decision instead of landing silently.",
         ];
     const repetidos = aMao.filter((v) => v.count > 1);
     const usos = repetidos.reduce((n, v) => n + v.count, 0);
@@ -166,7 +166,7 @@ export function oQueMuda(c) {
     linhas.push(`${aMao.length} of your design values are written by hand today. Importing gives each one a name in your own vocabulary, so changing it later means changing it once instead of finding every copy.`);
     if (repetidos.length > 0)
         linhas.push(`${repetidos.length} of those are repeated - ${usos} uses across your files. Every copy is a place the next change can be forgotten, which is how two screens end up almost the same colour.`);
-    linhas.push("And it stops coming back: once the system is in the repository, the check runs after every file your agent writes and catches a value that drifts off your own scale, before it ships.");
+    linhas.push("And it stops coming back: once the system is in the repository, the check runs at the end of every agent turn and catches a value that drifts off your own scale, before it ships.");
     return linhas;
 }
 /**
@@ -193,7 +193,7 @@ export function passos() {
         {
             comando: "npx synthesisui@latest connect",
             titulo: "Wire your agent",
-            porque: "Installs the check that runs after every file your agent writes, the tools it can query, and the skills that know this pipeline. Nothing of your code is touched or sent. Run it before you open the agent - a session only picks these up when it starts.",
+            porque: "Installs the check that runs at the end of every agent turn, the tools it can query, and the skills that know this pipeline. Nothing of your code is touched or sent. Run it before you open the agent - a session only picks these up when it starts.",
         },
         {
             comando: "npx synthesisui@latest import",

package/package.json

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