@unoverse-platform/studio 0.1.97 → 0.1.99

package/vendor/base/src/lint/design/index.mjs

@@ -67,7 +67,7 @@ export function lintDefinitions(designRoot, options = {}) {
         try {
           return (
             statSync(d).isDirectory() &&
-            ["components", "atoms", "styles", "apps"].some((s) => existsSync(join(d, s)))
+            ["components", "atoms", "styles", "apps", "agents"].some((s) => existsSync(join(d, s)))
           );
         } catch {
           return false;
@@ -96,9 +96,7 @@ export function lintDefinitions(designRoot, options = {}) {
   const DS = (() => {
     const onDisk = join(DESIGN_ROOT, "marketplace");
     if (existsSync(onDisk)) return onDisk;
-    const nodesHome = resolve(DESIGN_ROOT, "..", "nodes");
     for (const c of [
-      join(nodesHome, "marketplace", "definitions"),
       join(resolve(DESIGN_ROOT, "..", "plugins"), "node_modules", "@unoverse-platform", "marketplace", "definitions"),
     ])
       if (existsSync(c)) return c;
@@ -190,6 +188,9 @@ const isAppPath = (f) => homeSegments(f).includes("apps");
 // carry no manifest and declare no state tree, the face being the filename (§9b rule 7).
 const isTemplatePath = (f) => homeSegments(f).includes("templates");
 const isTemplatePart = (f) => isTemplatePath(f) && homeSegments(f).includes("components");
+// THE AGENT KIND (docs.unoverse.ai/design/tasks, 2026-09-06): one file under <org>/agents/,
+// a workflow listed for the map. Not a UI tree, so the tree rules do not apply; its own check does.
+const isAgentPath = (f) => homeSegments(f).includes("agents");
 // The DEFINITION ROOT folder for a file: a bare partial lives one level under it
 // (layouts/ states/ components/ blocks/); every `$include` resolves against it.
 const defRoot = (file) => {
@@ -597,7 +598,7 @@ const keyHomes = [
   [join(DS, "components"), true],
 ];
 for (const orgDir of orgDirs) {
-  keyHomes.push([join(orgDir, "components"), true], [join(orgDir, "apps"), true]);
+  keyHomes.push([join(orgDir, "components"), true], [join(orgDir, "apps"), true], [join(orgDir, "agents"), false]);
 }
 for (const [dir, isDir] of keyHomes) {
   if (!existsSync(dir)) continue;
@@ -638,7 +639,9 @@ for (const [dir, isDir] of keyHomes) {
 // carries are ordinary components, so they were never exempt from anything.
 const homes = [{ dir: join(DS, "components") }, { dir: join(DS, "atoms") }, { dir: join(DS, "templates") }];
 for (const orgDir of orgDirs) {
-  for (const sub of ["apps", "components", "templates"]) {
+  // `agents` (2026-09-06): a kind is linted; a home not enumerated is a home where every
+  // rule is off, silently.
+  for (const sub of ["apps", "components", "templates", "agents"]) {
     const d = join(orgDir, sub);
     if (existsSync(d) && statSync(d).isDirectory()) homes.push({ dir: d });
   }
@@ -701,64 +704,27 @@ for (const orgDir of orgDirs) {
         );
   }
 
-/**
- * ── the LATCH, on a state (docs/MCP_COMPLETE_GUIDE.md §The Component Latch) ──
- *
- * Declaring it makes whatever wears that face ADDRESSABLE: the pill goes up and the guest's
- * next sentences travel to that instance instead of opening a new answer. Every finding here
- * is something that produces a pill which looks fine and behaves wrongly, which is why they
- * are errors rather than warnings.
- *
- * Read from the ENVELOPE first and the manifest second, the same order the loader reads the
- * states tree in — a rule that judged only one home would pass whatever was authored in the
- * other.
- */
-const LATCH_KEYS = new Set(["title", "icon"]);
+// ── `latch`, RETIRED (2026-09-07) ──
+// The conversation is never "addressed at" a component: what is on screen is the server's
+// fact and the model reads it. A leftover block is an intent nothing honours, so it errors.
 for (const orgDir of orgDirs) {
   const adir = join(orgDir, "apps");
   if (!(existsSync(adir) && statSync(adir).isDirectory())) continue;
   for (const e of readdirSync(adir)) {
     const folder = join(adir, e);
-    let src, states;
     try {
       if (!statSync(folder).isDirectory()) continue;
-      // The envelope (`<name>.yaml`) is the app tree's home; the manifest is the legacy one.
-      const envelope = defPath(folder, e);
-      const manifest = defPath(folder, "manifest");
-      for (const p of [envelope, manifest]) {
+      for (const p of [defPath(folder, e), defPath(folder, "manifest")]) {
         if (!p || !existsSync(p)) continue;
-        const s = readDef(p).states;
-        if (s && typeof s === "object" && !Array.isArray(s)) {
-          src = p;
-          states = s;
-          break;
-        }
+        const states = readDef(p).states;
+        if (!states || typeof states !== "object" || Array.isArray(states)) continue;
+        for (const [sname, sentry] of Object.entries(states))
+          if (sentry && typeof sentry === "object" && !Array.isArray(sentry) && sentry.latch !== undefined)
+            report("error", p, `state "${sname}": "latch" is retired (2026-09-07). Delete the block — the model reads what is on screen; nothing addresses a component`);
       }
     } catch {
       continue; // a malformed envelope is reported elsewhere
     }
-    if (!states) continue;
-    for (const [sname, sentry] of Object.entries(states)) {
-      const latch = sentry && typeof sentry === "object" && !Array.isArray(sentry) ? sentry.latch : undefined;
-      if (latch === undefined) continue;
-      if (typeof latch !== "object" || latch === null || Array.isArray(latch)) {
-        report("error", src, `state "${sname}": "latch" must be a block ({ title, icon }), not ${Array.isArray(latch) ? "a list" : typeof latch}. Presence is what makes a state addressable, so a malformed one is an intent nothing can honour (docs/MCP_COMPLETE_GUIDE.md §The Component Latch)`);
-        continue;
-      }
-      // The pill is the ONLY sign the guest has that their words are landing on this page
-      // rather than the conversation. Unlabelled, it says nothing — and the compiler drops
-      // a titleless block, so the state would silently stop being addressable.
-      if (typeof latch.title !== "string" || !latch.title.trim())
-        report("error", src, `state "${sname}": "latch" needs a "title" — it is what the pill reads, and the pill is the only thing telling the guest what they are addressing. Name the thing, not the verb ("Your Perfect Day", not "Edit the day")`);
-      const extra = Object.keys(latch).filter((k) => !LATCH_KEYS.has(k));
-      if (extra.length)
-        report("error", src, `state "${sname}": "latch" has no key(s) ${extra.join(", ")}. The block is exactly ${[...LATCH_KEYS].join(", ")} — an invented key is silently ignored, so whatever it was meant to do never happens. The pill's colours belong to the design system's composer-bar, never to a state`);
-      // A STATE NOTHING CAN ENTER CANNOT BE ADDRESSED. The base state is the app at rest —
-      // the conversation itself — and `stateOrder` excludes it, so `resolveLatch` can never
-      // rank a base-state instance and the pill would never appear.
-      if (sname === Object.keys(states)[0])
-        report("error", src, `state "${sname}": it is the BASE state — the app at rest, which the priority ladder excludes by construction (stateOrder is every state BUT the base). A latch here can never resolve, so no pill would ever draw. Declare it on a state something ARRIVES into`);
-    }
   }
 }
 
@@ -778,8 +744,14 @@ const PLATFORM_HANDLERS = new Set(["getDetail"]); // named handlers needing no f
 // silently disable every rule after it.
 const credentialDefs = new Set();
 {
-  const nodesHome = resolve(DESIGN_ROOT, "..", "nodes");
+  // Every tier's node packages: the marketplace's and each org's, all at <tier>/nodes/.
+  const nodesHomes = [];
   try {
+    for (const tier of readdirSync(DESIGN_ROOT)) nodesHomes.push(join(DESIGN_ROOT, tier, "nodes"));
+  } catch {
+    /* no design root: nothing declares a credential */
+  }
+  for (const nodesHome of nodesHomes) try {
     for (const pkg of readdirSync(nodesHome)) {
       try {
         for (const f of readdirSync(join(nodesHome, pkg, "credentials"))) if (isDefFile(f)) credentialDefs.add(defName(f));
@@ -859,24 +831,8 @@ for (const orgDir of [DS, ...orgDirs]) {
       if (f.endsWith(".js") && !declared.has(f.slice(0, -3)))
         report("error", join(folder, f), `${f} is a lifecycle handler no manifest opted into. Add "${f.slice(0, -3)}" to the manifest's lifecycle array, or delete the file — un-opted code never runs`);
 
-    /**
-     * LATCH, RETIRED FROM THE MANIFEST (2026-08-31, MCP guide §The Component Latch).
-     *
-     * It moved to the STATE, in the app's own tree, beside that state's `layout:` and
-     * `preview:`. A component said one thing about itself for the whole of its life, but a
-     * page is addressable when it IS the page and not when it is a summary in the flow, and
-     * only the state knows which of those is on screen.
-     *
-     * An ERROR rather than a silent ignore: nothing reads this key any more, so a manifest
-     * still carrying it declares an intent that never happens, and the author has no way to
-     * tell that from a latch that simply does not work.
-     */
     if (readDef(mf).latch !== undefined)
-      report(
-        "error",
-        mf,
-        `"latch" is no longer a manifest key — it moved to the STATE (2026-08-31). Declare it on the app state this component is addressable IN, beside that state's layout: \`states: { <state>: { layout: ..., latch: { title: "..." } } }\`. Nothing reads a manifest latch, so this one produces no pill (docs/MCP_COMPLETE_GUIDE.md §The Component Latch)`,
-      );
+      report("error", mf, `"latch" is retired (2026-09-07). Delete the key — nothing reads it`);
   }
 }
 
@@ -910,9 +866,20 @@ function readAppSizes(dir) {
   try {
     const sizes = {};
     for (const [k, v] of Object.entries(readDef(p).appSize ?? {})) sizes[k] = typeof v === "string" ? v : v?.$value;
+    // `flex` IS THE SDK'S OWN WORD, NEVER A TOKEN (docs.unoverse.ai/design/apps): it means
+    // "fill the space remaining beside whatever core is open", on a slot and on a mounted
+    // template alike. A token named flex hard-codes ONE core's width and is wrong beside every
+    // other core: observed live 2026-09-10, an org's flex of 100% minus a 360px rail left a
+    // mounted grid overlapping a 480px voice core. The word is reserved; the file says so.
+    if (Object.prototype.hasOwnProperty.call(sizes, "flex"))
+      report("error", p, `app-sizes names "flex". flex is the SDK's own word (fill the space remaining beside whatever core is open), never a token: a token named flex hard-codes one core's width and is wrong beside every other core. Delete it; layouts keep writing appWidth: flex (docs.unoverse.ai/design/apps)`);
     return sizes;
-  } catch {
-    return null; // the file lints separately
+  } catch (e) {
+    // SAID, NOT SWALLOWED (2026-09-10): a sizes file that will not parse used to return null
+    // here, and the org silently inherited the foundation's set, so every width of its own
+    // "named no app size" and the real fault, a stray colon in the file, was never named.
+    report("error", p, `app-sizes is not valid ${p.endsWith(".json") ? "JSON" : "YAML"}: ${String(e?.message ?? e).split("\n")[0]}. Until it parses, none of this org's own sizes exist`);
+    return null;
   }
 }
 function appSizesForFile(file) {
@@ -975,13 +942,39 @@ function componentNamesForFile(file) {
   return names;
 }
 
+// THE PLACES APPS DECLARE (UNOVERSE_SCREEN.md §2.2), across the whole tree. A component is shared
+// by every app that shows it, so a state's `place:` is checked against every app's places, plus
+// `chat`. Read once per run: every app layout under any `apps/` folder, every `Place` node in it.
+let placeNamesCache;
+function placeNames() {
+  if (placeNamesCache !== undefined) return placeNamesCache;
+  const names = new Set();
+  const walk = (n) => {
+    if (Array.isArray(n)) return n.forEach(walk);
+    if (!n || typeof n !== "object") return;
+    if (n.type === "Place" && typeof n.name === "string") names.add(n.name);
+    for (const v of Object.values(n)) walk(v);
+  };
+  const roots = [DS, ...readdirSync(DESIGN_ROOT).filter((e) => !e.startsWith(".")).map((e) => join(DESIGN_ROOT, e))];
+  for (const root of new Set(roots))
+    for (const f of jsonFiles(join(root, "apps"))) {
+      try {
+        walk(parseDef(readText(f), f));
+      } catch {
+        /* an unreadable file is reported by its own lint; it declares no place here */
+      }
+    }
+  placeNamesCache = names;
+  return names;
+}
+
 
   // The run context: everything the extracted rule modules close over. Built here so it
   // cannot outlive the run, and passed once rather than threaded as ten parameters.
   const ctx = {
     DESIGN_ROOT, DS, orgDirs, report, spaceSteps, stepList, checkDimension, checkToken, checkCondition,
-    appSizesForFile, componentNamesForFile, refResolves, canonicalRef, declaredProps, atomsDirExists,
-    isFixture, isHook, isPropsExtract, isManifest, isAppPath, isTemplatePath, isTemplatePart, defRoot, readText,
+    appSizesForFile, componentNamesForFile, placeNames, refResolves, canonicalRef, declaredProps, atomsDirExists,
+    isFixture, isHook, isPropsExtract, isManifest, isAppPath, isTemplatePath, isTemplatePart, isAgentPath, defRoot, readText,
   };
   const walkNode = makeWalkNode(ctx);
   const lintFile = makeLintFile({ ...ctx, walkNode });

package/vendor/base/src/lint/design/vocabulary.mjs

@@ -13,7 +13,7 @@
 // ── ground truth (mirrors design/_schema/unoverse.schema.json + server guards) ──
 export const PRIMITIVES = new Set([
   "Box", "Stack", "Row", "Column", "Each", "Switch", "ComponentSlot", "Timeline",
-  "Text", "Image", "Button", "Input", "Select", "Markdown", "Skeleton", "Icon", "Ref", "Orb", "Template",
+  "Text", "Image", "Button", "Input", "Select", "Markdown", "Skeleton", "Icon", "Ref", "Orb", "Template", "Place",
 ]);
 export const CONDITION_KEYS = new Set(["field", "eq", "ne", "in"]);
 
@@ -78,7 +78,7 @@ export const PRIMITIVE_PROPS = {
   Column: ["children", "autoScroll", "revealOnStick", "appWidth"],
   Text: ["value"],
   Image: ["src", "alt"],
-  Markdown: ["value", "inheritLinkColor"],
+  Markdown: ["value", "inheritLinkColor", "citeAction"],
   Icon: ["icon", "name"],
   Skeleton: ["variant"],
   Orb: ["state", "size"],
@@ -94,6 +94,9 @@ export const PRIMITIVE_PROPS = {
   // template's machinery. `name` addresses the manifest's `templates:` entry;
   // `frame` is the dressing drawn around it when occupied.
   Template: ["name", "frame", "template", "director", "appWidth"],
+  // A PLACE (UNOVERSE_SCREEN.md §2.2): a named spot the screen shows interfaces into.
+  // `holds` is one or many; `frame` and `fallback` work as they do on a ComponentSlot.
+  Place: ["name", "holds", "frame", "fallback", "appWidth"],
   Timeline: ["user", "assistant", "userData", "assistantData", "autoScroll"],
 };
 

package/vendor/base/src/lint/design/walk.mjs

@@ -25,10 +25,12 @@ const SEARCH_KEYS = ["component", "type", "include", "pick", "items"];
 // The `object_type`s a place may admit. Apps and skills are absent by construction: the
 // page's own searches are SILENT (no app unlocked, no tool minted, no card lane, no
 // director woken), or every place would rain cards onto a page still assembling itself.
-const QUERY_TYPES = ["services", "images", "needs", "actions"];
+// `products` since migration 035 (2026-09-05; `services` retired 2026-09-07, `actions` with it:
+// no row is written as one). Each word maps to a declared spatial type (guarded by a test).
+const QUERY_TYPES = ["products", "images", "needs"];
 
 export function makeWalkNode(ctx) {
-  const { report, checkCondition, checkDimension, checkToken, appSizesForFile, componentNamesForFile, refResolves, canonicalRef, declaredProps, atomsDirExists, stepList, spaceSteps, isAppPath, isTemplatePath, defRoot } = ctx;
+  const { report, checkCondition, checkDimension, checkToken, appSizesForFile, componentNamesForFile, refResolves, canonicalRef, declaredProps, atomsDirExists, stepList, spaceSteps, isAppPath, isTemplatePath, isTemplatePart, defRoot } = ctx;
   // One director per LAYOUT FILE, tracked for this run only (each file is walked once).
   const directorsSeen = new Map();
 
@@ -36,6 +38,13 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
   if (Array.isArray(node)) return node.forEach((n) => walkNode(n, file, root, widthCap));
   if (!node || typeof node !== "object") return;
 
+  // THE ✕ BELONGS TO THE TEMPLATE'S LAYOUT, NEVER TO A PART (2026-09-07). `setValue` writes
+  // the interface's OWN slice (docs/design/state.md) and a part is its own interface, so a
+  // close inside a part retracts the PART into the chat column while the page stays open
+  // beside it (observed live: a page's hero, ✕ and all, sitting in the flow).
+  if (node.type === "Ref" && node.ref === "close-button" && isTemplatePart(file))
+    report("error", file, `a close-button inside a template PART writes the part's own slice, not the template's — the page stays open and the part falls into the chat. Move the ✕ to the template's layout (layouts/<state>.yaml), where its setValue writes the template's state`);
+
   // $include — resolves against the DEFINITION ROOT (layouts/ states/ components/…)
   if (typeof node.$include === "string") {
     const a = defPath(root, node.$include);
@@ -129,8 +138,9 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
             report("error", file, `a delivery band has no "${k}". It reads ${DELIVERY_KEYS.map((x) => `"${x}"`).join(", ")} (§9b; a place that names a component is a search place)`);
         if (d.pick !== undefined && (typeof d.pick !== "number" || d.pick < 1))
           report("error", file, `director.pick is a NUMBER — how many the director keeps, a cap the machine enforces (§9e rule 9)`);
-        if (d.rules !== undefined && typeof d.rules !== "string")
-          report("error", file, `director.rules is written like a brief: one string of English (§9b)`);
+        // NOTHING READS `rules`: the director's model was removed (UNOVERSE_SCREEN.md §2.7).
+        if (d.rules !== undefined)
+          report("warn", file, `director.rules is ignored: no model reads it any more. A band holds what arrives in search rank, up to pick. Remove it`);
         if (d.preview !== undefined && (!Array.isArray(d.preview) || d.preview.some((c) => typeof c !== "string")))
           report("error", file, `director.preview is an array of component names — Studio's stand-ins until a real run exists (§9b rule 6)`);
         else if (Array.isArray(d.preview)) {

package/vendor/base/src/lint/index.mjs

@@ -1,15 +1,19 @@
 /**
- * The linters. TWO of them, because there are two things to validate and they share
- * almost nothing.
+ * The linters. FOUR siblings, one per kind of thing a developer authors, and every kind
+ * is checked the same way: `unoverse lint`, the publish gate, CI, all through
+ * items/publish lintForPublish.
  *
- *   nodes/  node manifests: JSON Schema per part, plus the cross-file rules a schema
- *           cannot express (events matching output connectors, calls reachable by name,
- *           credentials declared in the package that needs them)
- *   design/ definitions: a CLOSED primitive set, a closed style vocabulary, token-only
- *           values, Switch discriminants, layouts reachable from a case
+ *   nodes/    node manifests: JSON Schema per part, plus the cross-file rules a schema
+ *             cannot express (events matching output connectors, calls reachable by name,
+ *             credentials declared in the package that needs them)
+ *   design/   definitions: a CLOSED primitive set, a closed style vocabulary, token-only
+ *             values, Switch discriminants, layouts reachable from a case
+ *   objects/  objects and pipelines: schema per file, plus the rules a schema cannot say
+ *   prompts/  Agent skills and prompt blocks: frontmatter that parses, the fields the
+ *             loaders need, and the discoverability contract on whenToUse
  *
- * They share `context.mjs` and nothing else. One reports on `api/run.yaml`, the other on
- * whether a colour is a raw hex. Merging them would produce a linter that is worse at both.
+ * They share `context.mjs` and nothing else. One reports on `api/run.yaml`, another on
+ * whether a colour is a raw hex. Merging them would produce a linter that is worse at all.
  *
  * WHY THEY LIVE HERE rather than in scripts/. The same rules are needed by four callers,
  * and only one of them is a terminal:
@@ -25,4 +29,6 @@
 
 export { lintNodes, hasErrors as nodesHaveErrors } from "./nodes/index.mjs";
 export { lintDefinitions, hasErrors as definitionsHaveErrors } from "./design/index.mjs";
+export { lintObjects, hasErrors as objectsHaveErrors } from "./objects/index.mjs";
+export { lintPrompts, hasErrors as promptsHaveErrors } from "./prompts/index.mjs";
 export { problems, report, rel, reset } from "./context.mjs";

package/vendor/base/src/lint/nodes/blocks.mjs

@@ -23,7 +23,7 @@ export const HANDLEBARS_HELPERS = new Set([
 ]);
 
 /**
- * The prompt-block library: prompts/blocks/**\/*.md, keyed the way the resolver keys them
+ * The prompt-block library: design/marketplace/blocks/**\/*.md, keyed the way the resolver keys them
  * (engine/src/template/promptBlocks.ts) — the filename camelCased, so markdown-guidelines.md is
  * referenced as {{prompt.markdownGuidelines}}.
  *
@@ -41,7 +41,11 @@ export const HANDLEBARS_HELPERS = new Set([
 const CACHE = new Map();
 
 export function promptBlocks() {
-  const home = resolve(state.nodesHome, "../prompts/blocks");
+  // The block library is the marketplace tier's. Beside the nodes when they ARE that
+  // tier (design/marketplace/{nodes,blocks}); one tier over for an org's own nodes
+  // (design/<org>/nodes → design/marketplace/blocks).
+  const home = [resolve(state.nodesHome, "../blocks"), resolve(state.nodesHome, "../../marketplace/blocks")]
+    .find((d) => existsSync(d)) ?? resolve(state.nodesHome, "../../marketplace/blocks");
   const cached = CACHE.get(home);
   if (cached) return cached;
 

package/vendor/base/src/lint/nodes/index.mjs

@@ -25,6 +25,7 @@ import { fileURLToPath } from "node:url";
 import { problems, derivedKinds, reset, report } from "../context.mjs";
 import { loadSchemas } from "./schema.mjs";
 import { lintPackage } from "./package.mjs";
+import { lintAttachments } from "./node.mjs";
 
 /**
  * Lint every node package under `nodesHome`.
@@ -72,6 +73,10 @@ export function lintNodes(nodesHome) {
     nodeCount += lintPackage(dir);
   }
 
+  // AFTER every package: an attachment names no host, so whether it fits one cannot be known
+  // until every node's configSchema has been read. See lintAttachments.
+  lintAttachments();
+
   const rank = { error: 0, warn: 1, hint: 2 };
   const sorted = [...problems].sort((a, b) => rank[a.level] - rank[b.level] || a.file.localeCompare(b.file));
   return { problems: sorted, derivedKinds: new Map(derivedKinds), nodeCount, pkgCount, nodesHome: home };

package/vendor/base/src/lint/nodes/node.mjs

@@ -12,7 +12,7 @@
  */
 import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
 import { join, relative, resolve, dirname } from "node:path";
-import { report, rel, refCounts, derivedKinds, allCredentials, state } from "../context.mjs";
+import { report, rel, refCounts, derivedKinds, allCredentials, attachments, configFields, state } from "../context.mjs";
 import { SCHEMA_ID, SECTIONS, validateAgainst, Validator } from "./schema.mjs";
 import { readYaml, resolveRefs, sharedDirFor } from "./load.mjs";
 import { HANDLEBARS_HELPERS, promptBlocks } from "./blocks.mjs";
@@ -110,6 +110,11 @@ export function lintNode(dir, pkg) {
       (spec?.calls ?? []).map((c, i) => ({ at: `service.${m}.calls[${i}]${c?.name ? ` (${c.name})` : ""}`, call: c })),
     ),
   ].filter((c) => c.call && typeof c.call === "object");
+  // THE CALLS INSIDE A TURN are calls like any other: their hosts, credentials and transports
+  // are checked the same way, or a repeat would be a way round every rule below.
+  for (const { at, call } of [...calls])
+    for (const [j, ic] of (Array.isArray(call?.repeat?.calls) ? call.repeat.calls : []).entries())
+      if (ic && typeof ic === "object") calls.push({ at: `${at}.repeat.calls[${j}]${ic.name ? ` (${ic.name})` : ""}`, call: ic });
 
   /**
    * Every LIST of calls in the node, with whether its last one may stream.
@@ -124,6 +129,11 @@ export function lintNode(dir, pkg) {
       .filter(([, spec]) => spec?.calls)
       .map(([m, spec]) => ({ at: `service.${m}.calls`, list: spec.calls, lastMayStream: false })),
   ];
+  // A TURN is a list of calls too: named, unique, and every one settles, because the next call,
+  // `until` and the next turn all read it.
+  for (const { at, list } of [...chains])
+    for (const [i, s] of (Array.isArray(list) ? list : []).entries())
+      if (Array.isArray(s?.repeat?.calls)) chains.push({ at: `${at}[${i}].repeat.calls`, list: s.repeat.calls, lastMayStream: false });
 
   // A PURE SERVICE node legitimately has no outputs: it is never triggered by the
   // graph, it answers callers and hands them a value. Any other node with no outputs
@@ -137,7 +147,17 @@ export function lintNode(dir, pkg) {
   // Both halves matter: a node with inputs but no outputs is still an error, because something
   // reaches it and then the data stops dead.
   const isAnnotation = !outputs.size && !(iface.inputs ?? []).length && !api;
-  if (!outputs.size && !api?.service && !isAnnotation)
+  /**
+   * AN ATTACHMENT is the third legitimate case, and the only one that is DECLARED rather than
+   * inferred from an absence. It clips onto another node and overrides that node's config
+   * (DECLARATIVE_NODES.md §14). It never runs, so it has no inputs, no outputs and no api, and
+   * it has no place in the data graph at all: there is nothing to wire it to.
+   *
+   * Declared rather than inferred because an attachment and a half-finished node look identical
+   * from the outside, and the whole point of `kind` is that a node says what it is.
+   */
+  const isAttachment = node.kind === "Attachment" || !!iface.attaches;
+  if (!outputs.size && !api?.service && !isAnnotation && !isAttachment)
     report("error", F.iface ?? F.node, `declares no outputs. A node that emits nothing cannot be wired to anything`);
 
   // The service channel must match what the node advertises. A method with no
@@ -160,6 +180,10 @@ export function lintNode(dir, pkg) {
      * advertised or nothing can reach it.
      */
     const DISCOVERY_METHOD = "getSchema";
+    /**
+     * A MENU entry names a component and nothing else (owner ruling 2026-09-20): the panel
+     * RUNS this node and draws what its events emitted, so there is no method to check here.
+     */
     for (const method of Object.keys(api?.service ?? {}))
       if (method !== DISCOVERY_METHOD && !advertised.has(method))
         report("error", F.api, `api/service.yaml has "${method}" but no serviceConnector with isService: true lists it in methods. Nothing can discover it`);
@@ -182,6 +206,21 @@ export function lintNode(dir, pkg) {
         `offers service methods and declares no outputs, so it is a pure service node and needs "template: service". Without it the canvas draws connector dots that can never carry anything (https://docs.unoverse.ai/nodes/manifest-nodes)`,
       );
 
+    /**
+     * A REPLY NEVER READS CONFIG (owner ruling 2026-09-20). A method's `returns` and its
+     * `renderComponents` go to a MODEL or a screen, and a box's settings are the author's:
+     * the runtime no longer puts `config` in that scope, so an expression reading it fails
+     * at run time with "config is not defined". Said here instead, at write time, with the
+     * reason. The CALLS still read config to build their requests; that is server-side.
+     */
+    for (const [method, spec] of Object.entries(api?.service ?? {})) {
+      for (const key of ["returns", "renderComponents"]) {
+        const text = typeof spec?.[key] === "string" ? spec[key] : spec?.[key] ? JSON.stringify(spec[key]) : "";
+        if (/\bconfig\./.test(text))
+          report("error", F.api, `api/service.yaml "${method}.${key}" reads config. A reply goes to a model and a box's settings are the author's, never the model's: compute what the caller may know in a call, or answer from params and the reply (https://docs.unoverse.ai/nodes/mcp-services)`);
+      }
+    }
+
     // The mirror of it: advertising the discovery method as a tool.
     if (advertised.has(DISCOVERY_METHOD))
       report("error", F.iface ?? F.node, `a serviceConnector lists "${DISCOVERY_METHOD}" in methods. It is tool DISCOVERY, called by convention, and listing it advertises it to the model as a tool (https://docs.unoverse.ai/nodes/mcp-services)`);
@@ -192,6 +231,52 @@ export function lintNode(dir, pkg) {
 
   // ── tier 3: semantics ──
 
+  /**
+   * ATTACHMENTS (DECLARATIVE_NODES.md §14). An attachment is configuration that arrives from
+   * outside a node and LOCKS what it owns: it clips onto the edge of a node whose configSchema
+   * has every field it sets, overrides those fields, and contributes a tab to that node's panel.
+   *
+   * The two halves must agree. `kind: Attachment` with no `attaches` is a node that clips onto
+   * nothing; `attaches` without the kind is an attachment the canvas will draw as an ordinary
+   * wireable box, which is the exact failure the guardrail ruling named ("a guardrail you must
+   * remember to wire is a suggestion").
+   */
+  if (node.kind === "Attachment" && !iface.attaches)
+    report("error", F.iface ?? F.node, `kind is "Attachment" but interface.yaml declares no "attaches". An attachment that sets nothing clips onto nothing (https://docs.unoverse.ai/nodes/manifest-nodes)`);
+  if (iface.attaches && node.kind !== "Attachment")
+    report("error", F.node, `declares "attaches" but kind is "${node.kind}". An attachment must SAY so, or the canvas draws it as an ordinary wireable box (https://docs.unoverse.ai/nodes/manifest-nodes)`);
+
+  if (isAttachment) {
+    // IT NEVER RUNS. Everything below is a way of running, and an attachment that declared one
+    // would be a node pretending to be data.
+    for (const [what, present, file] of [
+      ["inputs", (iface.inputs ?? []).length, F.iface],
+      ["outputs", outputs.size, F.iface],
+      ["serviceConnectors", (iface.serviceConnectors ?? []).length, F.iface],
+      ["api/run.yaml", api?.run?.length, F.api],
+      ["api/service.yaml", api?.service && Object.keys(api.service).length, F.api],
+      ["menu", (node.menu ?? []).length, F.node],
+    ])
+      if (present)
+        report("error", file ?? F.node, `is an Attachment but declares ${what}. An attachment never runs and has no place in the data graph: it sets config on the node it clips onto (https://docs.unoverse.ai/nodes/manifest-nodes)`);
+
+    /**
+     * ONE OWNER PER VALUE, applied to the attachment itself. A field it SETS on a host and also
+     * declares in its OWN configSchema is two surfaces editing one name, and the reader cannot
+     * tell which one is the lock. Anything variable belongs in its own config; anything it owns
+     * on the host is a literal.
+     */
+    const sets = Object.keys(iface.attaches?.sets ?? {});
+    const own = new Set(Object.keys(config?.configSchema?.properties ?? {}));
+    for (const f of sets.filter((f) => own.has(f)))
+      report("error", F.config ?? F.node, `sets "${f}" on its host AND declares it in its own configSchema. One owner per value: set it on the host, or own it here, never both (https://docs.unoverse.ai/nodes/manifest-nodes)`);
+
+    if (sets.length) attachments.set(label, { file: F.iface ?? F.node, sets, type: node.type });
+  } else if (config?.configSchema?.properties) {
+    // The other half of the cross-node check below: what a host has to offer an attachment.
+    configFields.set(label, new Set(Object.keys(config.configSchema.properties)));
+  }
+
   // kind is DECLARED but VERIFIED. Getting it wrong used to surface only at runtime.
   // A tool exchange is a multi-turn LOOP, so it makes the node a CallbackNode just as
   // surely as a streaming transport does, and it must name a connector that grants tools.
@@ -232,7 +317,7 @@ export function lintNode(dir, pkg) {
     // way anything leaves the node, so without it the node is a call into the void.
     if (!(api.events ?? []).length)
       report("error", F.api, `has run calls but no api/events.yaml. The events table is compulsory, it is the only way anything leaves a node (https://docs.unoverse.ai/nodes/manifest-nodes)`);
-  } else if (existsSync(join(dir, "src")) === false && !parts.api && !isAnnotation) {
+  } else if (existsSync(join(dir, "src")) === false && !parts.api && !isAnnotation && !isAttachment) {
     // An ANNOTATION node is exempt, because "does nothing" is the whole specification. `Note`
     // has no inputs, no outputs and no api: it is a markdown sticky on the canvas. Warning about
     // it would train a reader to ignore this message, which is the only thing that makes it
@@ -390,6 +475,22 @@ export function lintNode(dir, pkg) {
       if (s?.poll?.body && s.poll.method !== "POST")
         report("error", F.api, `${at}[${i}] (${s.name}) sets poll.body, which is only sent when poll.method is POST. As a GET it would be discarded`);
 
+      // A REPEAT entry makes no request of its own; its turn's calls do. It needs a turn, a way
+      // to stop and a bound, or it would make nothing, or never end until the platform's cap.
+      if (s?.repeat) {
+        if (!Array.isArray(s.repeat.calls) || !s.repeat.calls.length)
+          report("error", F.api, `${at}[${i}] (${s.name}) repeats with no calls, so a turn would do nothing (https://docs.unoverse.ai/nodes/calls-that-loop)`);
+        if (!s.repeat.until)
+          report("error", F.api, `${at}[${i}] (${s.name}) repeats with no "until", so only the turn bound would end it`);
+        if (s.repeat.maxTurns === undefined)
+          report("error", F.api, `${at}[${i}] (${s.name}) repeats with no "maxTurns"; the author's bound is compulsory, the platform's cap of 20 is only a backstop`);
+        if (Array.isArray(s.repeat.calls) && s.repeat.calls.some((c) => c?.repeat))
+          report("error", F.api, `${at}[${i}] (${s.name}) has a repeat inside its turn. Nested repeats multiply their bounds; a walk that needs a walk inside it is two nodes`);
+        for (const k of ["method", "url", "transport", "credential", "body", "retry", "headers", "query"])
+          if (k in s) report("error", F.api, `${at}[${i}] (${s.name}) sets "${k}" beside "repeat". A repeat makes no request of its own; its turn's calls do`);
+        continue;
+      }
+
       // A LOOP entry keeps an index rather than reaching a host, so the request keys are as
       // meaningless on it as they are on a state call.
       if (s?.loop) {
@@ -431,8 +532,17 @@ export function lintNode(dir, pkg) {
 
     // A step naming one that does not exist reads as empty, and the request goes out
     // with a hole in it rather than failing.
-    for (const [i, s] of list.entries())
-      for (const [, ref] of JSON.stringify(s ?? {}).matchAll(/\bcalls\.([A-Za-z0-9_]+)/g)) {
+    // A REPEAT is read in two parts. Its turn's calls are a chain of their own (checked there),
+    // and its `until` reads THAT turn's calls, never this list's; only what is left of it is
+    // read against this list.
+    for (const [i, s] of list.entries()) {
+      if (s?.repeat) {
+        const turn = Array.isArray(s.repeat.calls) ? s.repeat.calls.map((c) => c?.name) : [];
+        for (const [, ref] of String(s.repeat.until ?? "").matchAll(/\bcalls\.([A-Za-z0-9_]+)/g))
+          if (!turn.includes(ref)) report("error", F.api, `${at}[${i}] (${s.name}).repeat.until reads calls.${ref}, which is not a call in its turn`);
+      }
+      const own = s?.repeat ? { ...s, repeat: undefined } : s;
+      for (const [, ref] of JSON.stringify(own ?? {}).matchAll(/\bcalls\.([A-Za-z0-9_]+)/g)) {
         const earlier = names.slice(0, i);
         if (!earlier.includes(ref))
           report(
@@ -443,6 +553,7 @@ export function lintNode(dir, pkg) {
               : `${at}[${i}] (${s.name}) reads calls.${ref}, which is not a call in this list`,
           );
       }
+    }
   }
 
   // The narrator's call is not part of a list: nothing reads its reply back and it can
@@ -467,7 +578,7 @@ export function lintNode(dir, pkg) {
         report("error", F.api, `service.${name} declares "${old}". A method's calls are ALWAYS a list named "calls", even when there is one (https://docs.unoverse.ai/nodes/manifest-nodes)`);
 
   // Credentials must resolve to a declared type, or the run fails at execute time.
-  for (const c of iface.credentials ?? []) {
+  for (const c of [...(iface.credentials ?? []), ...(iface.attaches?.credentials ?? [])]) {
     const name = c.name;
     if (!pkg.credentials.has(name))
       report("error", F.iface ?? F.node, `needs credential "${name}" but no credentials/${name}.yaml exists in this package. A package DECLARES the credentials it needs (https://docs.unoverse.ai/nodes/credentials)`);
@@ -561,7 +672,7 @@ export function lintNode(dir, pkg) {
       for (const [, b] of body.matchAll(/\b(?:prompt|blocks)\.([A-Za-z0-9_]+)/g))
         if (!promptBlocks().has(b) && !seen.has(b)) {
           seen.add(b);
-          report("error", F.api, `references prompt block "{{prompt.${b}}}", which does not exist in prompts/blocks/. It resolves to empty and the instruction silently disappears`);
+          report("error", F.api, `references prompt block "{{prompt.${b}}}", which does not exist in design/marketplace/blocks/. It resolves to empty and the instruction silently disappears`);
         }
     }
   }
@@ -758,7 +869,46 @@ export function lintNode(dir, pkg) {
       // Nothing errors, and every downstream field reads empty.
       if (call.poll && pkg.requires.poll !== true)
         report("error", rel(pkg.file), `node ${node.type} waits on a job at ${at} but package.yaml requires.poll is not true`);
+      // A REPEATED call on an executor without it makes no request at all and settles on
+      // nothing: the node answers empty and nothing errors.
+      if (call.repeat && pkg.requires.repeat !== true)
+        report("error", rel(pkg.file), `node ${node.type} goes round in turns at ${at} but package.yaml requires.repeat is not true`);
     }
 
   return node;
 }
+
+/**
+ * THE LAST PASS: can each attachment ever clip onto anything?
+ *
+ * An attachment names no host. Compatibility IS the fields (DECLARATIVE_NODES.md §14): a node
+ * accepts it when that node's configSchema declares every field the attachment sets. That is
+ * what keeps the mechanism general — no `accepts:` list on the host to drift, no enum of kinds
+ * to widen for each new case — but it means the answer is not in the attachment's own folder.
+ * Its host may be in a package read later in the run, or in no package at all.
+ *
+ * So it is checked once, after every package, and it catches the mistake this design makes
+ * easy: a typo in a field name is not an error anywhere. The attachment lints clean, publishes,
+ * and then simply refuses to stick to anything, with nothing to read that says why.
+ *
+ * Reported as a WARNING, not an error. A universe may legitimately hold an attachment whose
+ * host lives in another universe, or one published ahead of the node it is for.
+ */
+export function lintAttachments() {
+  for (const [label, { file, sets, type }] of attachments) {
+    const hosts = [...configFields].filter(([, fields]) => sets.every((f) => fields.has(f)));
+    if (hosts.length) continue;
+
+    // Which field is the reason? The one the fewest nodes have is almost always the typo, and
+    // naming it is the difference between a usable warning and "it does not work".
+    const rarest = sets
+      .map((f) => ({ f, n: [...configFields.values()].filter((fields) => fields.has(f)).length }))
+      .sort((a, b) => a.n - b.n)[0];
+    const why = rarest?.n === 0 ? `no node declares "${rarest.f}"` : `no single node declares all of ${sets.map((f) => `"${f}"`).join(", ")}`;
+    report(
+      "warn",
+      file ?? label,
+      `attachment ${type ?? label} can clip onto nothing: ${why}. An attachment fits a node whose configSchema has every field it sets (https://docs.unoverse.ai/nodes/manifest-nodes)`,
+    );
+  }
+}