synthesisui 0.16.264 → 0.16.265

package/dist/claude-md.js

@@ -398,6 +398,32 @@ here: a newer reader sees styles the old one could not.`
      * servidor instala o hook, e o registro é pré-condição para este texto existir. Ensinar a instalar
      * uma capacidade que foi pré-requisito do próprio arquivo é redundância por construção.
      */
+    /**
+     * O RECALL SÓ É PROMETIDO ONDE ELE TEM ONDE CHEGAR - e este era um GAP de jornada.
+     *
+     * `recallAvailable` responde "o servidor MCP está registrado numa versão que serve `recall`", e essa
+     * é a pergunta certa sobre CAPACIDADE. Ela não é a pergunta sobre ALCANCE: `memoryReach` no servidor
+     * exige `installedSlug`, que ignora locks `adopted` porque um sistema adotado é lido do repositório e
+     * não tem linha de dashboard para a memória pertencer.
+     *
+     * Sem esta condição, um projeto só-adotado recebia um bootstrap dizendo *"what this project already
+     * DECIDED is `recall`"* e toda chamada respondia "no system installed here that belongs to a
+     * dashboard row" - o bootstrap prometendo uma ferramenta que não podia funcionar ali. As outras do
+     * bloco reduzido continuam valendo, porque `system_doctrine` e `find_token` leem arquivo local.
+     *
+     * Achado seguindo a jornada, não lendo o módulo: os dois lados estavam certos sobre a própria
+     * pergunta e ninguém comparava as duas.
+     */
+    const memoryReachable = recall.available && !onlyAdopted;
+    const memoryLine = memoryReachable
+        ? `
+
+**What this project already DECIDED is \`recall\`.** Call it when you begin work on an indexed
+subject, or when someone says "continue" and you need the current work-state. For the same subject
+and task, call it once - an empty result means there is nothing more to retrieve, so keep working. It
+tells you what was decided and why it matters; **the file on disk is still the authority for what is
+written now** - read the code before you edit it, never a remembered signature.`
+        : "";
     const rule = recall.available
         ? onlyAdopted
             ? `**These are true without asking anyone:** use the project's OWN custom properties, exactly as
@@ -406,13 +432,7 @@ new token invented in silence - say so instead, because a new token is a decisio
 is no component index for an adopted system: the tokens ARE the contract.
 
 **What the vocabulary IS is not written here.** Fetch only the piece the task requires:
-\`system_doctrine\` for the rules and the voice, \`find_token\` for a value you are about to write.
-
-**What this project already DECIDED is \`recall\`.** Call it when you begin work on a subject this
-system names, or when someone says "continue" and you need the current work-state. For the same
-subject and task, call it once - an empty result means there is nothing more to retrieve, so keep
-working. It tells you what was decided and why it matters; **the file on disk is still the authority
-for what is written now** - read the code before you edit it, never a remembered signature.${selfCheck}`
+\`system_doctrine\` for the rules and the voice, \`find_token\` for a value you are about to write.${memoryLine}${selfCheck}`
             : `**These are true without asking anyone:**
 
 - Semantic tokens only - \`var(--ds-color-semantic-*)\`, \`--ds-spacing-*\`. No raw values outside this
@@ -435,13 +455,7 @@ If nothing covers it, say which indexed entry you considered and why it did not
 
     describe_component   its parts, variants, states and the tokens it already uses
     system_doctrine      the rules and the voice of this system
-    playbook             the families, and what each one requires before it can be drawn
-
-**What this project already DECIDED is \`recall\`.** Call it when you begin work on an indexed
-subject, or when someone says "continue" and you need the current work-state. For the same subject
-and task, call it once - an empty result means there is nothing more to retrieve, so keep working. It
-tells you what was decided and why it matters; **the file on disk is still the authority for what is
-written now** - read the code before you edit it, never a remembered signature.${selfCheck}`
+    playbook             the families, and what each one requires before it can be drawn${memoryLine}${selfCheck}`
         : onlyAdopted
             ? `**When creating or editing components, read the system's GUIDE.md and follow it:** use the
 project's OWN custom properties, exactly as the guide lists them. Do not write raw colours,

package/dist/commands/connect.js

@@ -11,6 +11,7 @@ import { add } from "./add.js";
 import { reportWhatIsLeft } from "./align.js";
 import { ci } from "./ci.js";
 import { MCP_TOOL_COUNT } from "./mcp.js";
+import { installedSlugs } from "./sync.js";
 /**
  * `synthesisui connect` - put the three layers where they actually run.
  *
@@ -213,6 +214,21 @@ export async function connect(opts) {
     // after them, not before.
     const contract = await syncClaudeMd(root);
     console.log(section("Connected"));
+    /**
+     * E O QUE FALTA, DITO EM VOZ ALTA - porque este comando estava mentindo por omissão.
+     *
+     * `connect` liga a conta e registra o servidor MCP. Ele NÃO instala sistema, e sem lock o bloco
+     * gerenciado do `CLAUDE.md` sai VAZIO: o agente não recebe índice, não recebe invariante, e as duas
+     * ferramentas de memória recusam com "no system installed here". A saída dizia apenas "Connected",
+     * que é verdade e é inútil.
+     *
+     * Custou tempo de gente de verdade: 20/08, `codelevel-monorepo`. Rodou `connect`, conferiu o
+     * `CLAUDE.md`, achou o bloco vazio, e não havia nada dizendo que faltava um comando. Lacuna
+     * silenciosa é o que faz um produto correto parecer quebrado.
+     */
+    const anyInstalled = (await installedSlugs(root).catch(() => [])).length > 0;
+    if (!anyInstalled)
+        console.log(body("· no design system installed here yet - `synthesisui list` shows yours, and `synthesisui add <slug>` brings one in. Until then the agent has no index and memory has nothing to belong to."));
     /**
      * O QUE ESTE CLI REESCREVEU NA PASTA DO SISTEMA - dito primeiro, porque é o que a pessoa não sabia
      * que estava devendo. Ela rodou `connect` para atualizar a fiação; os arquivos do install estarem

package/dist/commands/mcp.js

@@ -9,8 +9,10 @@ import { readEvents } from "../doctor/ledger.js";
 import { fileRequest } from "../doctor/requests.js";
 import { diagnose, nameToWrite, scanSource } from "../doctor/scan.js";
 import { nearestToken, normalizeValue, tokenFor } from "../doctor/tokens.js";
-import { MEMORY_TOOLS } from "../memory/tools.js";
+import { fromCensus } from "../memory/observation.js";
+import { handleRecall, handleRemember, MEMORY_TOOLS } from "../memory/tools.js";
 import { repoStateOf } from "../repo-state.js";
+import { detectStack } from "../stack.js";
 import { component } from "./component.js";
 import { loadSystem, walkAll } from "./doctor.js";
 import { installedSlug, remeasure } from "./sync.js";
@@ -1247,6 +1249,39 @@ cli) {
  * procedência. Nenhuma linha dele conta nada: quem instrumenta é `callTool`,
  * uma vez, para todas.
  */
+/**
+ * O ELO QUE FALTAVA - `remember` e `recall` eram ANUNCIADOS e não despachados.
+ *
+ * As duas estavam na lista de `TOOLS` desde o primeiro dia, importadas no topo deste arquivo, com 152
+ * testes verdes atrás delas - e sem `case` no `runTool`. Um agente que as chamasse recebia
+ * `"unknown tool"` com `isError`. O `reachable.spec` não pegou porque IMPORTAR já conta como
+ * alcançável, e o próprio cabeçalho dele diz o que ele não cobre: *"nothing about whether the product
+ * calls it, and that gap is exactly where the work kept"*.
+ *
+ * Achado seguindo a jornada pelo ponto de entrada real, que é a lei 3. Um spec verde prova que a
+ * função roda; não prova que o produto a chama.
+ */
+async function memoryReach(root) {
+    const slug = await installedSlug(root);
+    if (!slug)
+        return "No system installed here that belongs to a dashboard row, so there is nothing to remember about. `synthesisui add <slug>` installs one.";
+    const token = await readToken();
+    if (!token)
+        return "Not signed in, so memory cannot be reached. A person has to run `synthesisui login` once in the terminal - it opens a browser, and I cannot complete it for them.";
+    return { slug, token, base: resolveRegistry() };
+}
+/** O censo já em disco, como Observation - o mesmo insumo que o `sync` mede. */
+async function localObservation(root) {
+    const raw = await readFile(join(root, "_synthesisui", "census.json"), "utf8").catch(() => null);
+    if (!raw)
+        return null;
+    try {
+        return fromCensus(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
 async function runTool(root, name, args) {
     switch (name) {
         case "check_file":
@@ -1406,6 +1441,68 @@ async function runTool(root, name, args) {
                 ? `${said}\n\nUPDATE THE DESIGN SYSTEM BEFORE CONTINUING.\nThe check that runs after your writes is pinned to ${behind} and these tools are ${VERSION}.\n\n  npx synthesisui@latest connect\n\nAsk the person, run it for them, and then say this: close and reopen the editor. The hook and the tools only rewire on a new session, so nothing you write before that is checked by the reader you are holding.`
                 : said);
         }
+        case "remember": {
+            const reach = await memoryReach(root);
+            if (typeof reach === "string")
+                return fromContract(reach);
+            /**
+             * A OBSERVAÇÃO É EXIGIDA para work-state, e só para ele: a condição de saída tem que ser
+             * verificável contra ESTE repositório, senão a memória nasce impossível de fechar.
+             */
+            const obs = await localObservation(root);
+            if (!obs)
+                return fromContract("No `_synthesisui/census.json` here, so nothing can be checked against this repository. Run `npx synthesisui sync` first - a work state whose condition nobody can measure is memory that starts lying.");
+            return handleRemember(args, obs, async (payload) => {
+                const res = await fetch(`${reach.base}/api/memory/${reach.slug}/remember`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        Authorization: `Bearer ${reach.token}`,
+                    },
+                    body: JSON.stringify(payload),
+                }).catch(() => null);
+                if (!res)
+                    return {
+                        accepted: false,
+                        reason: "unknown_field",
+                        details: "the platform could not be reached",
+                    };
+                const said = (await res.json().catch(() => null));
+                return (said ?? {
+                    accepted: false,
+                    reason: "unknown_field",
+                    details: `the platform answered ${res.status} with nothing readable`,
+                });
+            });
+        }
+        case "recall": {
+            const reach = await memoryReach(root);
+            if (typeof reach === "string")
+                return fromContract(reach);
+            /** A stack sai do repositório, nunca do agente: ela FILTRA, e um palpite dele cortaria regra boa. */
+            const stack = await detectStack(root);
+            return handleRecall(args, stack, async (request) => {
+                const res = await fetch(`${reach.base}/api/memory/${reach.slug}/recall`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        Authorization: `Bearer ${reach.token}`,
+                    },
+                    body: JSON.stringify(request),
+                }).catch(() => null);
+                const empty = {
+                    carried: [],
+                    groups: [],
+                    omitted: [],
+                    because: res
+                        ? `the platform answered ${res.status}`
+                        : "the platform could not be reached",
+                };
+                if (!res?.ok)
+                    return empty;
+                return ((await res.json().catch(() => null)) ?? empty);
+            });
+        }
         case "request_token": {
             const name = String(args.name ?? "");
             // TRIAGE AT FILING: if the system's own contract already promises this

package/dist/install-marks.js

@@ -115,7 +115,7 @@
  * O índice de componentes é BYTE-IDÊNTICO nos dois caminhos - mesma fonte canônica, mesmos nomes,
  * mesma quantidade (`claude-md.f0.spec.ts`). O corte troca uma frase, nunca o inventário.
  */
-export const MATERIALISER_SINCE = "0.16.264";
+export const MATERIALISER_SINCE = "0.16.265";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *

package/dist/memory/tools.js

@@ -62,7 +62,7 @@ export const MEMORY_TOOLS = [
                 },
                 subject: {
                     type: "string",
-                    description: "What this is ABOUT - a token, a component, a library. Required for rationale.",
+                    description: "decision and rationale only, and required for rationale. What this is ABOUT - a token, a component, a library. A work-state says it inside `exit.subject` instead, so sending it here is refused: a field nobody reads would look accepted.",
                 },
                 exit: {
                     type: "object",
@@ -254,16 +254,62 @@ export async function handleRecall(args, stack, ask) {
         ...(args.task ? { task: args.task } : {}),
         budget,
     });
+    /**
+     * O TRABALHO EM ABERTO VEM PRIMEIRO, e é o que responde "onde eu estava".
+     *
+     * Decisões dizem como construir; o work-state diz o que estava sendo construído. Quando alguém diz
+     * "continue", a segunda pergunta é a única que importa - e ela vinha da plataforma e era descartada
+     * aqui, porque o tipo não tinha o campo.
+     *
+     * Cada linha carrega a AUTORIDADE ao lado: um estado que ninguém mediu é hipótese, e um medido há
+     * seis dias é a última coisa que se sabe. Sem o rótulo o agente trata os dois como fato corrente.
+     */
+    const open = (out.work ?? []).map((w) => {
+        const moved = w.remaining !== null
+            ? `  ${w.remaining} left${w.moved ? ` · ${w.moved}` : ""}`
+            : w.moved
+                ? `  ${w.moved}`
+                : "";
+        return `- ${w.goal}  [${w.status} · ${w.says}]${moved}`;
+    });
+    const work = open.length > 0
+        ? `Open work, yours:\n${open.join("\n")}\n\nWhat this project decided:\n`
+        : "";
     if (out.carried.length === 0)
-        return {
-            body: `Nothing recorded that applies here. ${out.because}`,
-            source: { kind: "none", reason: "system", detail: "nothing applies" },
-        };
-    const lines = out.carried.map((m) => `- ${m.text}${m.applies.length > 0 ? `  [${m.applies.join(", ")}]` : ""}  (${m.rung})`);
+        return open.length > 0
+            ? answer(`Open work, yours:\n${open.join("\n")}\n\nNo decisions recorded that apply here. ${out.because}`, "memory:recall")
+            : {
+                body: `Nothing recorded that applies here. ${out.because}`,
+                source: { kind: "none", reason: "system", detail: "nothing applies" },
+            };
+    /**
+     * E O FRESCOR ATRAVESSA ATÉ AQUI - senão ele é um campo que ninguém lê.
+     *
+     * `memoriesOf` deriva `evidence` e `confirmedAt` do sinal `survived` mais recente, o único que
+     * atesta o CÓDIGO. Eles cruzavam o JSON, existiam no tipo, e esta linha renderizava só o degrau: o
+     * agente continuava sem distinguir "confirmada hoje" de "escrita uma vez há quarenta dias", que é
+     * exatamente o problema que o frescor foi criado para resolver. A mesma classe do `work`, e eu a
+     * reintroduzi ao consertar a primeira.
+     *
+     * O degrau responde quanto acreditamos; o frescor responde se ainda é verdade. As duas coisas vão
+     * juntas ou nenhuma das duas significa algo.
+     */
+    const fresh = (m) => {
+        if (m.type === "rationale")
+            return "stated by a person, never measured";
+        if (m.evidence === "measured" && m.confirmedAt)
+            return `your code backed this on ${m.confirmedAt.slice(0, 10)}`;
+        if (m.evidence === "declared")
+            return "declared, not measured yet";
+        if (m.evidence === "imported")
+            return "read from your code at import";
+        return "no measurement on record";
+    };
+    const lines = out.carried.map((m) => `- ${m.text}${m.applies.length > 0 ? `  [${m.applies.join(", ")}]` : ""}  (${m.rung} · ${fresh(m)})`);
     const grouped = out.groups.length > 0
         ? `\n\nSame subject, so they travel together: ${out.groups
             .map((g) => g.members.join(" + "))
             .join(" · ")}`
         : "";
-    return answer(`${lines.join("\n")}${grouped}\n\n${out.because}`, "memory:recall");
+    return answer(`${work}${lines.join("\n")}${grouped}\n\n${out.because}`, "memory:recall");
 }

package/package.json

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