@unoverse-platform/studio 0.1.91 → 0.1.92

package/local/plugin.ts

@@ -26,7 +26,6 @@ import { loadLocalNodes, type LocalNodes } from "./nodes.js";
 import { credentialsFromEnv, keyPresence, readEnv } from "./keys.js";
 import { readSource, saveSource, sourceFiles, writableRoots } from "./source.js";
 import { atomNames, vocabulary } from "./authoring.js";
-import { buildTools, handleMcp, mintPairingCode } from "./mcp.js";
 
 /**
  * A definition URI's home on disk: a component's folder, or an app's.
@@ -169,14 +168,6 @@ export function localStudioHost(): Plugin {
   let baseSrc: string;
   /** The node the developer last picked in the preview, for an agent to read. */
   let selection: Record<string, unknown> | null = null;
-  /** The agent tool surface, built on first use so the catalog is loaded by then. */
-  let mcpTools: ReturnType<typeof buildTools> | null = null;
-  /** This package's own root, for the vendored authoring skill. */
-  // Derived from this module's own URL, never RESOLVED: `createRequire().resolve("./plugin.js")`
-  // throws here, because Vite loads the TypeScript source and no sibling .js exists. Throwing
-  // at plugin construction kills the config load, which stops the dev server restarting at
-  // all, and the symptom is every new route 404ing with no error in the browser.
-  const appRoot = resolve(fileURLToPath(import.meta.url), "../..");
 
   return {
     name: "local-studio-host",
@@ -242,7 +233,7 @@ export function localStudioHost(): Plugin {
         // 200. That has now cost three separate bugs (the /api allowlist, the dev proxy for
         // /.well-known and /publish), each of which looked like a missing route rather than
         // a filtered one.
-        if (!/^\/(dev|local|mcp|skills|prompt-blocks|registry|nodes|keys|execute)\b/.test(path)) return next();
+        if (!/^\/(dev|local|skills|prompt-blocks|registry|nodes|keys|execute)\b/.test(path)) return next();
 
         /** Read a JSON request body. */
         const body = async (): Promise<Record<string, unknown>> => {
@@ -515,49 +506,6 @@ export function localStudioHost(): Plugin {
             case path === "/local/selection":
               return json(res, selection ?? { empty: true });
 
-            /**
-             * CONNECT AN AGENT. Mints the code the developer pastes into Claude, the same
-             * flow Canvas uses. Ten minutes, single use, burned on redeem.
-             */
-            case path === "/local/pair" && req.method === "POST":
-              return json(res, mintPairingCode());
-
-            /** The MCP endpoint itself. Same origin, same port, no separate install. */
-            case path === "/mcp" && req.method === "POST": {
-              mcpTools ??= buildTools(
-                {
-                  projectRoot,
-                  catalog: async () => (await catalog) as never,
-                  sourceFiles: (uri) => {
-                    const home = definitionHome(uri, c, projectRoot);
-                    return home ? sourceFiles(home, writableRoots(projectRoot, c), projectRoot) : [];
-                  },
-                  readSource: (p) => readSource(p, writableRoots(projectRoot, c), projectRoot),
-                  saveSource: async (p, text) => {
-                    type LintModule = { lintDefinitions(designRoot: string): { problems: { level?: string; file?: string }[] } };
-                    const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
-                    recentSelfWrites.set(resolve(p), Date.now());
-                    return saveSource(p, text, writableRoots(projectRoot, c), projectRoot, (designRoot) =>
-                      lintMod.lintDefinitions(designRoot),
-                    );
-                  },
-                  lintProject: async () => {
-                    type LintModule = { lintDefinitions(designRoot: string): { problems: unknown[] } };
-                    const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
-                    return lintMod.lintDefinitions(designHome(projectRoot));
-                  },
-                  selection: () => selection,
-                  vocabulary: async () => {
-                    const vocabMod = (await ssr(`${baseSrc}/lint/design/vocabulary.mjs`)) as unknown as Parameters<typeof vocabulary>[0];
-                    return vocabulary(vocabMod, c.resolveTheme("light"), atomNames(projectRoot), c.listDefinitions("component") as { name?: string }[]);
-                  },
-                },
-                appRoot,
-              );
-              await handleMcp(req, res, await body(), mcpTools);
-              return;
-            }
-
             case path === "/skills":
               return json(res, { skills: readMarkdownLibrary(resolve(projectRoot, "prompts/skills")) });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unoverse-platform/studio",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "type": "module",
   "description": "Unoverse Studio: the local authoring app. Reads your own rx/ folder, no backend.",
   "scripts": {

package/vendor/base/src/agent-mcp/invoke.ts

@@ -53,7 +53,19 @@ export async function connectPlatformMcp(
     authFetch ? { fetch: authFetch } : undefined,
   );
   await client.connect(transport);
-  return { client, close: () => client.close().catch(() => {}) };
+  // TERMINATE, then close. `client.close()` only aborts the local fetch; the server keeps
+  // the session (its McpServer, ~70 compiled tool schemas) until an HTTP DELETE arrives,
+  // and the SDK sends that ONLY from `terminateSession()`. Every native call here opens
+  // a fresh session (one per card render, one per discovered app per turn), so without
+  // the DELETE the server's session map grew until restart. Best-effort: a failed
+  // DELETE falls back to the server's idle sweep (mcp/routes.ts).
+  return {
+    client,
+    close: async () => {
+      await transport.terminateSession().catch(() => {});
+      await client.close().catch(() => {});
+    },
+  };
 }
 
 export async function invokeComponentAppNative(
@@ -74,6 +86,7 @@ export async function invokeComponentAppNative(
           ...(ctx.props ? { props: ctx.props } : {}),
           ...(ctx.instanceId ? { instanceId: ctx.instanceId } : {}),
           ...(ctx.fromRow ? { fromRow: true } : {}),
+          ...(ctx.shell ? { shell: true } : {}),
           ...(ctx.batch ? { batch: ctx.batch } : {}),
         },
       },

package/vendor/base/src/agent-mcp/lean.ts

@@ -51,6 +51,9 @@ export function leanToolResultForModel(resultContent: string): string {
     if (!parsed || !Array.isArray(parsed.results)) return resultContent;
     const lean = {
       count: parsed.count,
+      // THE SEARCH'S MIRROR (MCP_APP_PROTOCOL §0.1): what the delivery put on screen. The
+      // one key the model must read before the rows; kept verbatim.
+      ...(typeof parsed.screen === "string" && parsed.screen ? { screen: parsed.screen } : {}),
       results: parsed.results.map((r: Record<string, any>) => {
         const m = (r.metadata ?? {}) as Record<string, unknown>;
         const meta: Record<string, unknown> = {};

package/vendor/base/src/agent-mcp/rowComponents.ts

@@ -32,7 +32,27 @@ export function rowComponentsFromResults(results: unknown): RowComponent[] {
   const seen = new Set<string>();
   if (!Array.isArray(results)) return out;
   for (const item of results as any[]) {
-    if (item?.object_type === "mcp") continue; // registry apps are TOOLS (path A/B above)
+    if (item?.object_type === "mcp") {
+      /**
+       * A REGISTRY ROW THAT IS A COMPONENT ARRIVES AS ITS SHELL (TEMPLATE_MODEL §12e "One
+       * ladder, one delivery", ruled 2026-09-04). A bindingless component (a manifest, no
+       * workflow — the card finder) used to be only UNLOCKED here as a tool and rendered a
+       * turn later when the model called it; meanwhile the display cards from the same
+       * search had already landed, so a `page` card held the screen for the second before
+       * the `focus` component existed. Now it lands in the SAME delivery as the cards, in
+       * its declared state, and the ladder decides among them at once. Delivered, never
+       * invoked: no row props, no outputs collected — the model's own call (still minted
+       * by discovery) merges its arguments into this slice and collects the answers.
+       * Workflow-bound apps (path A) and native MCP tools stay tools.
+       */
+      const uri = item?.metadata?.app;
+      if (typeof uri !== "string" || !uri.startsWith("unoverse://components/") || item.metadata?.workflow || item.metadata?.schema?.methods) continue;
+      const component = componentTypeFromAppUri(uri);
+      if (!component || seen.has(component)) continue;
+      seen.add(component);
+      out.push({ id: component, component, props: {}, shell: true });
+      continue;
+    }
     const app = item?.metadata?.app;
     if (typeof app !== "string" || !app.startsWith("unoverse://components/") || item.metadata.workflow) continue;
     const component = componentTypeFromAppUri(app);
@@ -87,24 +107,47 @@ export function onEmptyRowDelivery(fn: (chatId: string) => void): void {
   emptyDeliveryListener = fn;
 }
 
+/** What the delivery did with one row: rendered, held back by the director or the ladder,
+ *  delivered as a shell, or failed. The search's MIRROR is written from these. */
+export interface RowOutcome {
+  component: string;
+  id: string;
+  action: "rendered" | "held-back" | "shell" | "failed";
+}
+
+/**
+ * THE SEARCH'S MIRROR (MCP_APP_PROTOCOL §0.1, ruled 2026-09-05): one line saying what the
+ * delivery put on screen and what it did not show, so the model answers the screen and
+ * not the rows. Empty when nothing is on screen (card-only deliveries do not mirror).
+ */
+export function screenLine(outcomes: RowOutcome[]): string {
+  const shown = outcomes.filter((o) => o.action === "shell" || o.action === "rendered");
+  const hidden = outcomes.filter((o) => o.action === "held-back");
+  if (!shown.some((o) => o.action === "shell")) return "";
+  const on = shown.map((o) => (o.action === "shell" ? `${o.component} (on screen, in its opening state)` : o.component)).join(", ");
+  const off = hidden.length ? ` Not shown: ${hidden.length} result card(s), ranked below it on the app's ladder — do not describe them as visible.` : "";
+  return `On screen: ${on}. Answer by pointing the guest to what is on screen.${off}`;
+}
+
 export function renderRowComponents(
   items: RowComponent[] | undefined,
   ctx: AppInvocationContext,
   log?: (msg: string) => void,
-): void {
+): Promise<RowOutcome[]> {
   // No live session (builder/test/headless callers) → nothing to render; the
   // search stays pure automatically — no flag juggling needed by the caller.
-  if (!ctx.userId) return;
+  if (!ctx.userId) return Promise.resolve([]);
   if (!items?.length) {
     // The search ran on a live session and surfaced nothing — say so (§12e).
     if (ctx.chatId) emptyDeliveryListener?.(ctx.chatId);
-    return;
+    return Promise.resolve([]);
   }
   // ONE DELIVERY, announced as a batch (UNOVERSE_TEMPLATE_MODEL §12e): the server's
   // director waits for all siblings, judges once, and only the held set renders —
   // in verdict order, before anything reaches the screen.
   const batchId = `${ctx.chatId ?? ctx.conversationId ?? "b"}:${Math.random().toString(36).slice(2, 8)}`;
   let index = 0;
+  const outcomes: Promise<RowOutcome>[] = [];
   for (const item of items) {
     // Per-row instance id: keys the render `<component>:<rowId>` server-side, so
     // multiple rows sharing one component each get their OWN slice (and a repeat
@@ -117,13 +160,32 @@ export function renderRowComponents(
     // Without it the brief referee judges the row — a component that renders the Document
     // inherits its prose/keyFacts briefs and gets rejected for parts nobody composes.
     // Fire-and-forget, log on settle: a slow render must not hold up the answer.
-    invokeComponentAppNative(item.component, { ...ctx, message: "", props: item.props, instanceId: item.id, fromRow: true, batch: { id: batchId, size: items.length, index: index++ } })
-      // "RENDERED" must mean rendered: a director-dropped card resolves too
-      // (action: "held-back") and saying RENDERED for it is the exact
-      // proof-of-nothing this log line was once rewritten to stop telling.
-      .then((r) => log?.(r.action === "held-back" ? `🧩 HELD BACK ${item.component} (${item.id})` : `🧩 RENDERED ${item.component} (${item.id})`))
-      .catch((e: any) => log?.(`🧩 FAILED ${item.component} (${item.id}) — ${e?.message ?? e}`));
+    // A shell keys the component's own slice (no per-row instance), so the model's later
+    // call for the same component merges into it rather than drawing a second one.
+    outcomes.push(
+      invokeComponentAppNative(item.component, {
+        ...ctx,
+        message: "",
+        props: item.props,
+        ...(item.shell ? { shell: true } : { instanceId: item.id }),
+        fromRow: true,
+        batch: { id: batchId, size: items.length, index: index++ },
+      })
+        // "RENDERED" must mean rendered: a director-dropped card resolves too
+        // (action: "held-back") and saying RENDERED for it is the exact
+        // proof-of-nothing this log line was once rewritten to stop telling.
+        .then((r): RowOutcome => {
+          const action: RowOutcome["action"] = r.action === "held-back" ? "held-back" : r.action === "shell" ? "shell" : "rendered";
+          log?.(action === "held-back" ? `🧩 HELD BACK ${item.component} (${item.id})` : `🧩 RENDERED ${item.component} (${item.id})`);
+          return { component: item.component, id: item.id, action };
+        })
+        .catch((e: any): RowOutcome => {
+          log?.(`🧩 FAILED ${item.component} (${item.id}) — ${e?.message ?? e}`);
+          return { component: item.component, id: item.id, action: "failed" };
+        }),
+    );
   }
+  return Promise.all(outcomes);
 }
 
 /** `unoverse://components/journey-finder` → `journey-finder`;

package/vendor/base/src/agent-mcp/types.ts

@@ -88,6 +88,9 @@ export interface AppInvocationContext {
   instanceId?: string;
   /** These props are ROW DATA, not a model's composition — skip the brief referee. */
   fromRow?: boolean;
+  /** Deliver the component's SHELL only: render it in its declared state and return
+   *  at once — never collect its outputs (§12e "Discovery delivers; it never invokes"). */
+  shell?: boolean;
   /** The delivery batch this render belongs to (UNOVERSE_TEMPLATE_MODEL §12e): the
    *  server's director judges the WHOLE batch before anything renders. `size` is how
    *  many siblings to wait for; `index` is this render's arrival position. */
@@ -127,4 +130,9 @@ export interface RowComponent {
   component: string;
   /** The row's content AS-IS — the component's state (binds resolve by name). */
   props: Record<string, unknown>;
+  /** A SHELL delivery (TEMPLATE_MODEL §12e "One ladder, one delivery"): the row is a
+   *  component that takes input (a manifest, no workflow). It arrives in the same
+   *  delivery as the cards, in its declared state, with its own defaults and NO row
+   *  props; it is never invoked here — its form opens only on the model's call. */
+  shell?: boolean;
 }

package/vendor/base/src/auth/auth.ts

@@ -83,8 +83,37 @@ function parseStringClaim(payload: JWTPayload, claimName: string): string | unde
   return undefined;
 }
 
+/**
+ * VERIFIED TOKENS, REMEMBERED UNTIL THEY EXPIRE. A token is immutable: the same string
+ * verifies to the same user every time until `exp`, and nothing here checks revocation
+ * on the way (it never did). Yet every request on /mcp, /stream, /api/* and every
+ * per-click user_action paid a full RS256 verify, and the proxy and trigger paths paid
+ * it TWICE (gate, then enrichment). Bounded and insertion-evicted; an entry is trusted
+ * only while `now < exp`, so an expired token is re-verified and refused exactly as
+ * before. The JWKS fetch was already cached by jose; this caches the verify.
+ */
+const VERIFIED_MAX = 1000;
+/** Cache life for a token that carries no `exp` (jose still verified it). */
+const VERIFIED_NO_EXP_MS = 60_000;
+const verified = new Map<string, { user: AuthUser; until: number }>();
+
 /** Validate a bearer token and extract the user, or null if invalid/unconfigured. */
 export async function validateJWT(token: string): Promise<AuthUser | null> {
+  const hit = verified.get(token);
+  if (hit) {
+    if (Date.now() < hit.until) return hit.user;
+    verified.delete(token);
+  }
+  const user = await verifyJWT(token);
+  if (user) {
+    const exp = typeof user.raw.exp === "number" ? user.raw.exp * 1000 : Date.now() + VERIFIED_NO_EXP_MS;
+    if (verified.size >= VERIFIED_MAX) verified.delete(verified.keys().next().value as string);
+    verified.set(token, { user, until: exp });
+  }
+  return user;
+}
+
+async function verifyJWT(token: string): Promise<AuthUser | null> {
   const jwksSet = getJWKS();
   const issuers = getIssuerCandidates();
   if (!jwksSet || issuers.length === 0) {

package/vendor/base/src/definitions/fsCache.ts

@@ -101,6 +101,33 @@ export function readTextCached(path: string): string {
  * than a missing filter.
  */
 export function dirSignature(dirs: string[]): string {
+  // MEMOIZED FOR A SHORT WINDOW. The sweep is cheap once, but `loadDefinition` computes
+  // it on EVERY call, and the callers are bursts: `listDefinitions` loads ~270
+  // components per request, tool registration loads every app per MCP initialize, and
+  // a streaming publish re-resolves its definition per chunk. Measured on the real tree
+  // that was ~1ms of blocked event loop per call, so a catalogue read was ~30k sync
+  // syscalls. Within the window the signature is reused; an edit still shows within
+  // SIGNATURE_TTL_MS, which is below the reload latency a developer can perceive.
+  const key = dirs.join("\0");
+  const now = Date.now();
+  const hit = signatures.get(key);
+  if (hit && now - hit.at < SIGNATURE_TTL_MS) return hit.sig;
+  const sig = computeDirSignature(dirs);
+  signatures.set(key, { at: now, sig });
+  return sig;
+}
+
+const SIGNATURE_TTL_MS = 500;
+const signatures = new Map<string, { at: number; sig: string }>();
+
+/** Drop every memoized signature, so the next `dirSignature` sweeps the disk again.
+ *  For code that has JUST written a definition and must read it back within the window
+ *  (tests, an installer). Steady-state callers never need this. */
+export function forgetDirSignatures(): void {
+  signatures.clear();
+}
+
+function computeDirSignature(dirs: string[]): string {
   const parts: string[] = [];
   const walk = (dir: string) => {
     for (const e of readdirSync(dir, { withFileTypes: true })) {

package/vendor/base/src/definitions/registry/catalog.ts

@@ -7,7 +7,7 @@
 
 import { readdirSync, existsSync, statSync } from "fs";
 import { join } from "path";
-import { readDefCached, defPath, isDefFile, defName } from "../fsCache.js";
+import { readDefCached, defPath, isDefFile, defName, dirSignature, cachedBySignature } from "../fsCache.js";
 import { SHARED_DIR, appDirs, templateDirs, componentDirs, resolveComponentDirs, parseRef, projectDir, listOrgs } from "./homes.js";
 import type { UnoverseDefinition } from "../model.js";
 import { normalizeDeclaredKind, defaultLayoutOf } from "../model.js";
@@ -362,8 +362,25 @@ export function loadTemplateApp(id: string, org?: string): AppManifest | null {
 }
 
 /** List MCP apps — every TEMPLATE app (one org's, or all orgs') PLUS every universal
- *  COMPONENT app (a component with a manifest.json). Both are native MCP app tools. */
+ *  COMPONENT app (a component with a manifest.json). Both are native MCP app tools.
+ *
+ *  MEMOIZED ON THE TREE'S SIGNATURE, like every other catalogue read. This walk (every
+ *  org's apps, components and templates, a manifest load per entry) ran on every MCP
+ *  initialize, twice per anonymous MCP message, on every app open and every sitetool
+ *  read, and nothing in it changes between requests except when a file is edited. The
+ *  returned array is SHARED: callers read it (find/filter/map), never mutate it. */
 export function listApps(org?: string): AppManifest[] {
+  const orgsToWalk = org != null ? [org] : listOrgs();
+  const dirs = [
+    ...appDirs(org ?? null).map((d) => d.dir),
+    ...(org == null ? [SHARED_DIR.component] : []),
+    ...orgsToWalk.map((o) => join(projectDir(o), "components")),
+    ...templateDirs(org ?? null).map((d) => d.dir),
+  ];
+  return cachedBySignature(`apps:${org ?? "*"}`, dirSignature(dirs), () => walkApps(org, orgsToWalk));
+}
+
+function walkApps(org: string | undefined, orgsToWalk: string[]): AppManifest[] {
   const out: AppManifest[] = [];
   // PER-ENTRY ISOLATION (same law as listDefinitions): this list is built INSIDE MCP
   // server construction, so one unloadable app taking the walk down means EVERY
@@ -402,7 +419,6 @@ export function listApps(org?: string): AppManifest[] {
   // and a discovered org component fails with "Tool <id> not found" (observed live:
   // PerfectDay after the two-tier move). Tool id stays the bare component id (names are
   // unique across tiers, lint-enforced); the org rides on the manifest for addressing.
-  const orgsToWalk = org != null ? [org] : listOrgs();
   for (const o of orgsToWalk) {
     const dir = join(projectDir(o), "components");
     if (!existsSync(dir)) continue;