synthesisui 0.16.29 → 0.16.30

package/dist/commands/doctor.js

@@ -4,7 +4,7 @@ import { findDivergences } from "../doctor/coherence.js";
 import { findFrozenBindings } from "../doctor/frozen.js";
 import { appendEvent, readEvents, summarize } from "../doctor/ledger.js";
 import { bindingsFromDocument, countComponents, findOverrides, } from "../doctor/overrides.js";
-import { readRequests } from "../doctor/requests.js";
+import { checkableName, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
 import { diagnose, scanSource, siblingTokens, } from "../doctor/scan.js";
 import { findSelfConflicts, forbiddenProps, isReset, propMatchesLabel, } from "../doctor/self-conflict.js";
 import { buildTable, EMPTY_TABLE, nearestToken, } from "../doctor/tokens.js";
@@ -575,12 +575,24 @@ export async function doctor(opts) {
      * that actually hit the gap.
      */
     if (hasSystem && scopes.length === 0) {
+        // Verification first: whether an ask is still missing is a FACT about
+        // the installed css, so the queue re-checks before it reports. A request
+        // the build now delivers closes itself and says so - nobody marks done
+        // what a machine can see is done (dono, 29/07).
+        const verified = await verifyAndCloseRequests(root);
+        if (verified.length > 0) {
+            console.log("");
+            console.log(section("Requests verified"));
+            for (const r of verified) {
+                console.log(body(`  ✓ ${r.id}  ${checkableName(r) ?? r.name} - the installed system covers it now. Closed.`));
+            }
+        }
         const requests = await readRequests(root);
         if (requests.length > 0) {
             console.log("");
             console.log(section("What your agent asked for"));
             for (const r of requests.slice(0, 8)) {
-                console.log(body(`  ${r.id}  ${r.kind === "token" ? `token ${r.value} as ${r.name}` : `component "${r.name}"`}`));
+                console.log(body(`  ${r.id}  ${r.kind === "token" ? `token ${r.value} as ${r.name}` : `component "${r.name}"`}${r.area === "platform" ? "  [platform]" : ""}`));
                 console.log(body(`          for: ${r.purpose}`));
                 if (r.considered)
                     console.log(body(`          considered: ${r.considered}`));
@@ -590,6 +602,9 @@ export async function doctor(opts) {
             }
             console.log("");
             console.log(body("Author it in the studio, or close it: synthesisui request --done <id>"));
+            if (requests.some((r) => r.area === "platform")) {
+                console.log(body("[platform] items are the synthesisui team's - no action needed; they close themselves when an update delivers."));
+            }
         }
     }
     /**

package/dist/commands/mcp.js

@@ -220,19 +220,54 @@ async function callTool(root, name, args) {
             return text(`Filed as ${r.id}. It shows up in \`synthesisui doctor\` until a person authors it or closes it - keep building with your workaround, and say in your summary that the request exists.`);
         }
         case "request_token": {
+            const name = String(args.name ?? "");
+            // TRIAGE AT FILING: if the system's own contract already promises this
+            // name (a keyframe exists, so `animate-<it>` should too), the gap is
+            // DELIVERY - ours, not the author's. It files routed to the platform,
+            // the owner is never asked to act, and it closes itself the moment a
+            // doctor/sync finds the promise kept in the installed css.
+            const area = (await isPromisedByContract(root, name))
+                ? "platform"
+                : undefined;
             const r = await fileRequest(root, {
                 kind: "token",
-                name: String(args.name ?? ""),
+                name,
                 purpose: String(args.purpose ?? ""),
                 value: String(args.value ?? ""),
                 file: args.file ? String(args.file) : undefined,
+                ...(area ? { area } : null),
             });
-            return text(`Filed as ${r.id}. Do not add the token yourself - the request shows up in \`synthesisui doctor\` for a person to decide.`);
+            return text(area
+                ? `Filed as ${r.id} and routed to the synthesisui platform team - the system's contract already promises this and the shipped css does not deliver it. No one needs to act: it closes itself when an update lands. Keep the quiet base meanwhile.`
+                : `Filed as ${r.id}. Do not add the token yourself - the request shows up in \`synthesisui doctor\` for a person to decide.`);
         }
         default:
             return text(`No tool named ${name}.`, true);
     }
 }
+/**
+ * Does the installed system's own contract promise this token name? The one
+ * case a machine can be sure of today: `animate-<x>` where `<x>` is a
+ * keyframe the document declares - the vocabulary section is generated FROM
+ * those keyframes, so asking for one means the promise exists and the
+ * artifact failed it (the exact shape of the first field-filed request,
+ * hvdoyc, 29/07).
+ */
+async function isPromisedByContract(root, name) {
+    const m = /animate-([a-z0-9-]+)/.exec(name);
+    if (!m)
+        return false;
+    const kebab = (v) => v.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    const { documents } = await loadSystem(root);
+    for (const raw of documents) {
+        const doc = raw;
+        for (const k of Object.keys(doc.motion?.keyframes ?? {})) {
+            if (kebab(k) === m[1])
+                return true;
+        }
+    }
+    return false;
+}
 /**
  * One request in, one response out - or null for a notification, which MUST
  * NOT be answered. Replying to `notifications/initialized` is the classic way

package/dist/commands/sync.js

@@ -2,7 +2,7 @@ import { readdir, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { readToken, resolveRegistry } from "../config.js";
 import { readEvents } from "../doctor/ledger.js";
-import { closeRequest, readRequests } from "../doctor/requests.js";
+import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
 import { body, section } from "../output.js";
 /**
  * What each decision means ON THIS MACHINE - the card decides, the sync
@@ -82,6 +82,10 @@ export async function sync(opts) {
         console.log(body("No installed system here, so there is nowhere to sync to."));
         return;
     }
+    // Verification first, so the snapshot never reports "open" about something
+    // the installed css already delivers - a request closes because a machine
+    // CHECKED, not because someone remembered to say so (dono, 29/07).
+    const verified = await verifyAndCloseRequests(root);
     const events = await readEvents(root);
     const requests = await readRequests(root);
     if (events.length === 0 && requests.length === 0) {
@@ -111,6 +115,14 @@ export async function sync(opts) {
     const out = (await res.json());
     console.log(section("Sync"));
     console.log(body(`${out.eventsReceived} checks sent, ${out.eventsNew} new. ${out.requestsNow} open request${out.requestsNow === 1 ? "" : "s"}.`));
+    // Closed by CHECKING, not by word: the installed css now delivers these.
+    if (verified.length > 0) {
+        console.log("");
+        console.log(body("Verified against the installed css, closed here:"));
+        for (const r of verified) {
+            console.log(body(`  ✓ ${r.id} ${checkableName(r) ?? r.name} - delivered. Nothing for anyone to do.`));
+        }
+    }
     // Decisions travel BACK: the owner answered on the card, and this - the
     // person's own sync, on their machine - is what closes the local file.
     // Nobody hunts an id: deciding on the card and running sync is the whole

package/dist/doctor/requests.js

@@ -1,4 +1,4 @@
-import { appendFile, readFile, writeFile } from "node:fs/promises";
+import { appendFile, readdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 /**
  * RECUSA → PEDIDO: the refusal becomes the request queue.
@@ -72,3 +72,89 @@ export async function closeRequest(root, id) {
     await writeFile(path(root), keep.length ? `${keep.map((r) => JSON.stringify(r)).join("\n")}\n` : "", "utf8");
     return true;
 }
+/**
+ * REQUESTS CLOSE BY VERIFICATION, NOT BY WORD (dono, 29/07: "não deveria ser
+ * automático e verificado no deploy?").
+ *
+ * A token request names what was missing. Whether it is still missing is a
+ * FACT about the installed css, so the queue re-checks it on every doctor and
+ * sync: once `--animate-rise` (or `--ds-<name>`) exists in what is actually
+ * installed, the request closes itself and says so. Trust-based closing
+ * ("Mark authored") remains only for what a machine cannot check.
+ *
+ * Only the conservative direction is automated: a false "still open" costs a
+ * glance; a false "satisfied" silently buries a real gap. Component requests
+ * and prose-named tokens stay manual.
+ */
+/** The name a token request is checkable by: its first kebab-case run.
+ *  Agents write prose around it ("animate-rise (and animate-fade / ...)"). */
+export function checkableName(req) {
+    if (req.kind !== "token")
+        return null;
+    const m = /[a-z][a-z0-9]*(?:-[a-z0-9]+)+/.exec(req.name.trim());
+    return m ? m[0] : null;
+}
+/** Requests whose ask the installed css now demonstrably delivers. */
+export function satisfiedRequests(requests, installedCss) {
+    return requests.filter((r) => {
+        const name = checkableName(r);
+        if (!name)
+            return false;
+        const candidates = name.startsWith("animate-")
+            ? [`--${name}`]
+            : [`--ds-${name}`, `--${name}`];
+        return candidates.some((c) => installedCss.includes(`${c}:`));
+    });
+}
+/**
+ * Everything the pinned install actually ships, as one string - tokens.css
+ * AND theme.css of the locked version, for every installed system. This is
+ * the ground verification stands on: not the doc, not the GUIDE's promises,
+ * the css a build would really read.
+ */
+export async function readInstalledCss(root) {
+    const dsDir = join(root, "_synthesisui", "ds");
+    let css = "";
+    let slugs = [];
+    try {
+        slugs = (await readdir(dsDir, { withFileTypes: true }))
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return "";
+    }
+    for (const s of slugs) {
+        const raw = await readFile(join(dsDir, s, ".lock"), "utf8").catch(() => "");
+        let version;
+        try {
+            version = JSON.parse(raw).version;
+        }
+        catch {
+            // no lock, no pinned folder to read
+        }
+        if (!version)
+            continue;
+        for (const f of ["tokens.css", "theme.css"]) {
+            css += `\n${await readFile(join(dsDir, s, `v${version}`, f), "utf8").catch(() => "")}`;
+        }
+    }
+    return css;
+}
+/**
+ * The whole gesture: read, verify against the installed css, close what is
+ * now delivered, and report each closure. Shared by doctor and sync so the
+ * queue never says "open" about something the build already ships.
+ */
+export async function verifyAndCloseRequests(root) {
+    const requests = await readRequests(root);
+    if (requests.length === 0)
+        return [];
+    const css = await readInstalledCss(root);
+    if (!css)
+        return [];
+    const satisfied = satisfiedRequests(requests, css);
+    for (const r of satisfied)
+        await closeRequest(root, r.id);
+    return satisfied;
+}

package/package.json

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