@unoverse-platform/studio 0.1.115 → 0.1.117

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

@@ -0,0 +1,67 @@
+/**
+ * ONE URI FOR EVERY TASK (docs/mcp/MCP_TASKS.md § 2a, ruled 2026-10-10).
+ *
+ * Every task, of every kind (a form, a component, a template, an app, a workflow's Task Start, a
+ * pipeline), is `unoverse://tasks/<org>/<name>`. The URI is an address, never a file: it points at
+ * the asset that is the task. This module is the only place that reads or writes it; nothing else
+ * knows another spelling.
+ *
+ * It accepts exactly two forms: the URI, and the same identity written short, `<org>/<name>` (what
+ * live pages carry in `data-unoverse-interface`). Everything else is refused, so a caller holding an
+ * old spelling finds out here rather than saving or calling under a second name. A marketplace
+ * task with no org of its own is in the org `marketplace`.
+ *
+ * Pure: no files, no registry.
+ */
+
+export const TASK_SCHEME = "unoverse://tasks/";
+
+/** The org of a marketplace task that belongs to no org. */
+export const MARKETPLACE_ORG = "marketplace";
+
+const ORG = /^[a-z0-9][a-z0-9-]*$/;
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+export interface TaskParts {
+  org: string;
+  name: string;
+}
+
+/** The task's parts, from its URI or its short form; null for anything else. */
+export function taskParts(input: unknown): TaskParts | null {
+  if (typeof input !== "string") return null;
+  const raw = input.trim();
+  const body = raw.startsWith(TASK_SCHEME) ? raw.slice(TASK_SCHEME.length) : raw.includes("://") ? null : raw;
+  if (body === null) return null;
+  const parts = body.split("/");
+  if (parts.length !== 2) return null;
+  const [org, name] = parts;
+  if (!ORG.test(org) || !NAME.test(name)) return null;
+  return { org, name };
+}
+
+/** The task's URI, `unoverse://tasks/<org>/<name>`, from either form; null for anything else. */
+export function taskUri(input: unknown): string | null {
+  const p = taskParts(input);
+  return p ? `${TASK_SCHEME}${p.org}/${p.name}` : null;
+}
+
+/** The URI of a task from its org (none: the marketplace) and its name. */
+export function taskUriOf(org: string | null | undefined, name: string): string | null {
+  return taskUri(`${org || MARKETPLACE_ORG}/${name}`);
+}
+
+/** The short form, `<org>/<name>`: what definitions are looked up by (`loadDefinition`). */
+export function taskShort(input: unknown): string | null {
+  const p = taskParts(input);
+  return p ? `${p.org}/${p.name}` : null;
+}
+
+/**
+ * The task's MCP tool name, `<org>.<name>`. MCP tool names cannot hold `://` or `/`, so the name on
+ * the wire is made from the URI by this one rule, never by hand.
+ */
+export function taskToolName(input: unknown): string | null {
+  const p = taskParts(input);
+  return p ? `${p.org}.${p.name}` : null;
+}

package/vendor/base/src/http/uwsFetchAdapter.ts

@@ -31,6 +31,8 @@ const STATUS_TEXT: Record<number, string> = {
   404: "Not Found",
   405: "Method Not Allowed",
   406: "Not Acceptable",
+  413: "Payload Too Large",
+  429: "Too Many Requests",
   500: "Internal Server Error",
 };
 const statusLine = (code: number): string => `${code} ${STATUS_TEXT[code] ?? "OK"}`;
@@ -154,9 +156,23 @@ function writeCors(res: HttpResponse): void {
   res.writeHeader("Access-Control-Max-Age", "86400");
 }
 
-/** Buffer the full request body; resolves on the last chunk (copies as it goes). */
-function readBody(res: HttpResponse): Promise<Buffer> {
+/**
+ * LIMITS FOR A PUBLIC DOOR (docs/auth-security/INBOUND.md § 3). A route anyone can call says how
+ * much it will read and whether to read at all, so a flood or an oversized body is refused before
+ * it costs anything. Optional: every route without them reads as it always did.
+ */
+export interface FetchLimits {
+  /** The most bytes this route reads. Over it: 413, and the rest is never buffered. */
+  maxBody?: number;
+  /** Asked before a single byte is read; false is 429. The route's rate limit. */
+  admit?: (path: string) => boolean;
+}
+
+/** Buffer the full request body; resolves on the last chunk (copies as it goes), or null once it passes `maxBody`. */
+export function readBody(res: Pick<HttpResponse, "onData">, maxBody = Infinity): Promise<Buffer | null> {
   return new Promise((resolve) => {
+    let size = 0;
+    let over = false;
     // Collect copies and concat ONCE at the end. The old per-chunk
     // `Buffer.concat([buf, chunk])` reallocated+copied the whole accumulator on every
     // chunk — O(n²) in body size, which hurts large /execute payloads. Each chunk is
@@ -167,6 +183,13 @@ function readBody(res: HttpResponse): Promise<Buffer> {
       // ArrayBuffer after this callback returns. `Buffer.from(arrayBuffer)` is only a
       // VIEW (no copy), so wrap in a Uint8Array, which Buffer.from then copies; deferring
       // a bare view to the final concat would read detached memory.
+      if (over) return;
+      size += chunk.byteLength;
+      if (size > maxBody) {
+        over = true;
+        chunks.length = 0;
+        return resolve(null);
+      }
       chunks.push(Buffer.from(new Uint8Array(chunk)));
       if (isLast) resolve(chunks.length === 1 ? chunks[0] : Buffer.concat(chunks));
     });
@@ -181,6 +204,7 @@ export async function handleFetch(
   res: HttpResponse,
   req: HttpRequest,
   handler: (request: Request) => Promise<Response>,
+  limits: FetchLimits = {},
 ): Promise<void> {
   const state: PumpState = { aborted: false };
   // THE HANDLER LEARNS OF THE DISCONNECT. `Request.signal` is how a Fetch handler is told
@@ -215,8 +239,20 @@ export async function handleFetch(
     return;
   }
 
-  const body = method !== "GET" && method !== "HEAD" ? await readBody(res) : undefined;
+  const refuse = (code: 413 | 429): void => {
+    res.cork(() => {
+      res.writeStatus(statusLine(code));
+      res.writeHeader("Content-Type", "application/json");
+      writeCors(res);
+      res.end(JSON.stringify({ error: code === 413 ? "too large" : "too many requests" }));
+    });
+  };
+  if (limits.admit && !limits.admit(new URL(url).pathname)) return refuse(429);
+  if (limits.maxBody !== undefined && Number(headers["content-length"] ?? 0) > limits.maxBody) return refuse(413);
+
+  const body = method !== "GET" && method !== "HEAD" ? await readBody(res, limits.maxBody) : undefined;
   if (state.aborted) return;
+  if (body === null) return refuse(413);
 
   let response: Response;
   try {

package/vendor/base/src/items/collect.ts

@@ -91,6 +91,16 @@ function orgDesignSystemDir(dir: string): string {
 }
 
 /** Collect an org repo into items: the same walk as a monorepo project, rooted at the repo. */
+/**
+ * EVERY KIND THE WALK READS from an org's folder. A sync that reads a folder with this walk
+ * knows each of these completely: none of a kind in the folder means none in the org, so the
+ * sync may remove what is gone. A kind not listed (a recipe) is never read here, so a sync
+ * never removes it.
+ */
+export const COLLECTED_KINDS: ReadonlySet<string> = new Set([
+  "component", "app", "template", "atom", "identity", "agent", "object", "pipeline", "style", "skill", "prompt-block", "node",
+]);
+
 export function collectOrg(home: OrgHome): CollectedItem[] {
   return collectFrom(home.dir, home.org, orgDesignSystemDir(home.dir));
 }

package/vendor/base/src/items/publish.ts

@@ -118,6 +118,16 @@ export async function lintOrg(home: OrgHome): Promise<{ problems: Finding[]; err
   return { problems: result.problems, errors: result.problems.filter((p: Finding) => p.level === "error") };
 }
 
+/**
+ * Lint an org repo's objects and pipelines with some files as they WOULD be (`overlay`: absolute path ->
+ * text): a change is checked before it is written (an approved table wording, pipelines/tables.md).
+ */
+export async function lintOrgObjects(home: OrgHome, overlay: Record<string, string> = {}): Promise<{ problems: Finding[]; errors: Finding[] }> {
+  const { lintObjects } = await import("../lint/objects/index.mjs");
+  const problems = lintObjects(home.dir, { org: { name: home.org, dir: home.dir }, overlay }).problems;
+  return { problems, errors: problems.filter((p: Finding) => p.level === "error") };
+}
+
 /**
  * What publishing WOULD do, without doing it.
  *

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

@@ -693,7 +693,10 @@ for (const orgDir of orgDirs) {
   // 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 });
+    // AN AGENT FOLDER (agents/<name>/agent.yaml, docs/architecture/signal/AGENTS.md § 3) is not a
+    // definition: the objects linter checks it, as it does a pipeline folder. Only a flat file
+    // directly in agents/ is the older Agent file, still checked here until it is converted.
+    if (existsSync(d) && statSync(d).isDirectory()) homes.push(sub === "agents" ? { dir: d, flat: true } : { dir: d });
   }
 }
 
@@ -865,7 +868,10 @@ for (const orgDir of [DS, ...orgDirs]) {
       // This was an org-blocking error until it stopped a yasisland deploy over a form
       // nobody needed that day.
       if (credentialDefs.size)
-        for (const cname of Array.isArray(readDef(mf).credentials) ? readDef(mf).credentials : [])
+        for (const entry of Array.isArray(readDef(mf).credentials) ? readDef(mf).credentials : [])
+          // `- googleApiCredential` or `- googleApiCredential: MapKey` (the saved name chooses
+          // between two of one type); the definition looked for is the TYPE either way.
+          for (const cname of typeof entry === "string" ? [entry] : entry && typeof entry === "object" ? Object.keys(entry) : [String(entry)])
           if (!credentialDefs.has(String(cname)))
             report(
               "warn",
@@ -1039,7 +1045,12 @@ function placeNames() {
   const walkNode = makeWalkNode(ctx);
   const lintFile = makeLintFile({ ...ctx, walkNode });
 
-  for (const home of homes) for (const f of jsonFiles(home.dir)) lintFile(f);
+  for (const home of homes) {
+    const files = home.flat
+      ? readdirSync(home.dir).filter((f) => !f.startsWith(".") && isDefFile(f) && !statSync(join(home.dir, f)).isDirectory()).map((f) => join(home.dir, f))
+      : jsonFiles(home.dir);
+    for (const f of files) lintFile(f);
+  }
   return { problems, homes, designRoot: DESIGN_ROOT, designSystem: DS };
 }
 

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

@@ -72,7 +72,7 @@ export const INTERFACE_FIELDS = new Set([
 export const AUTHORED_CONTROLS = ["maxLength", "minItems", "maxItems", "enum"];
 
 export const PRIMITIVE_PROPS = {
-  Box: ["children", "autoScroll", "revealOnStick", "selection", "appWidth"],
+  Box: ["children", "autoScroll", "revealOnStick", "selection", "appWidth", "pan"],
   Stack: ["children", "autoScroll", "revealOnStick", "appWidth"],
   Row: ["children", "autoScroll", "revealOnStick", "appWidth"],
   Column: ["children", "autoScroll", "revealOnStick", "appWidth"],

package/vendor/base/src/lint/objects/index.d.mts

@@ -17,6 +17,7 @@ export interface ObjectsResult {
   problems: Finding[];
   objectCount: number;
   pipelineCount: number;
+  agentCount: number;
   designRoot: string;
 }
 

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

@@ -22,7 +22,7 @@ import { problems, reset, report, state } from "../context.mjs";
 import { validateAgainst, Validator } from "../nodes/schema.mjs";
 import {
   envelopeFindings, propsFindings, fromFindings, serviceFindings, makeFindings, rowKeyFindings, objectTestFindings,
-  pipelineFindings, pipelineFolderFindings,
+  pipelineFindings, pipelineFolderFindings, layoutFindings,
 } from "./rules.mjs";
 
 const require_ = createRequire(import.meta.url);
@@ -46,6 +46,7 @@ export const SCHEMA_ID = {
   config: "https://docs.unoverse.ai/schemas/pipelines/config.schema.json",
   interface: "https://docs.unoverse.ai/schemas/pipelines/interface.schema.json",
   pipelineTest: "https://docs.unoverse.ai/schemas/pipelines/test.schema.json",
+  agent: "https://docs.unoverse.ai/schemas/agents/agent.schema.json",
 };
 
 /**
@@ -57,7 +58,7 @@ export const SCHEMA_ID = {
  */
 function schemaDirs() {
   const out = [];
-  for (const kind of ["objects", "pipelines", "nodes"]) {
+  for (const kind of ["objects", "pipelines", "agents", "nodes"]) {
     for (const c of [join(HERE, "_schema", kind), resolve(HERE, `../../../../docs/schemas/${kind}`), join(HERE, "../nodes/_schema")]) {
       if (existsSync(c)) {
         out.push(c);
@@ -161,6 +162,28 @@ export function lintObjects(designRoot, options = {}) {
     }
     return out;
   };
+  /**
+   * THE MARKETPLACE MCPS, by task name (MCP_TASKS.md § 2a): every marketplace node that offers MCP
+   * tools (`serviceType: mcp` in its interface), its type in kebab case. Null when the marketplace
+   * is not seen.
+   */
+  const marketplaceMcps = () => {
+    if (!marketplaceSeen) return null;
+    const out = new Set();
+    const home = join(marketplace, "nodes");
+    if (!isDir(home)) return out;
+    for (const pkg of readdirSync(home)) {
+      const nodes = join(home, pkg, "nodes");
+      if (!isDir(nodes)) continue;
+      for (const n of readdirSync(nodes)) {
+        const iface = join(nodes, n, "interface.yaml");
+        if (!existsSync(iface) || !/serviceType:\s*mcp\b/.test(readFileSync(iface, "utf8"))) continue;
+        const m = /^type:\s*([A-Za-z0-9_]+)/m.exec(existsSync(join(nodes, n, "node.yaml")) ? readFileSync(join(nodes, n, "node.yaml"), "utf8") : "");
+        out.add((m ? m[1] : n).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase());
+      }
+    }
+    return out;
+  };
   const foldersIn = (tierDir, kind) => {
     const home = join(tierDir, kind);
     if (!isDir(home)) return [];
@@ -340,9 +363,104 @@ export function lintObjects(designRoot, options = {}) {
     if (tier.org && marketplacePipelines.has(name)) report("error", at("pipeline.yaml"), `pipeline ${name}: an org's pipeline may not take a marketplace pipeline's name; the connector's name would be ambiguous`);
   }
 
+  /**
+   * AGENTS (docs/architecture/signal/AGENTS.md § 3, § 3a): one folder each, `agents/<name>/`, its
+   * `agent.yaml` and its soul. The schema says the shape; these say what a schema cannot: the
+   * folder and the name agree, the skills and the soul exist, each task's URI names a task of the
+   * org, each trigger names a node there is, and the soul gives no orders. A flat file directly in
+   * agents/ is the older Agent file, checked by the design linter until it is converted.
+   */
+  let agentCount = 0;
+  for (const tier of tiers) {
+    if (!tier.org) continue;
+    for (const name of foldersIn(tier.dir, "agents")) {
+      agentCount++;
+      const dir = join(tier.dir, "agents", name);
+      const file = join(dir, "agent.yaml");
+      const at = rel(file);
+      const doc = readYaml(file);
+      if (doc == null) {
+        if (!existsSync(file)) report("error", rel(dir), `agent ${name}: the folder holds no agent.yaml`);
+        continue;
+      }
+      validateAgainst(SCHEMA_ID.agent, doc, at, `agent ${name}`);
+      if (doc.name !== name) report("error", at, `agent ${name}: name is "${doc.name}"; it must equal the folder`);
+      // NO BUDGET, NO AGENT, enforced where it runs: Signal refuses to switch it on (AGENTS.md § 9).
+      // Here it is a warning, so a draft Agent still syncs and shows in Studio as "not set", and
+      // never holds back the rest of its org's update (owner, 2026-10-10).
+      if (!isRecord(doc.model) || !doc.model.use) report("warn", at, `agent ${name}: no model set; it cannot be switched on until model.use is set`);
+      if (!isRecord(doc.budget) || !doc.budget.perDay) report("warn", at, `agent ${name}: no daily budget set; it cannot be switched on until budget.perDay is set`);
+      for (const skill of Array.isArray(doc.skills) ? doc.skills : []) {
+        if (!existsSync(join(tier.dir, "skills", skill, "SKILL.md")) && !existsSync(join(marketplace, "skills", skill, "SKILL.md"))) {
+          report("error", at, `agent ${name}: skill "${skill}" is not in skills/`);
+        }
+      }
+      if (typeof doc.soul === "string") {
+        const soulFile = join(dir, doc.soul);
+        if (!existsSync(soulFile)) report("error", at, `agent ${name}: its soul, ${doc.soul}, is not beside agent.yaml`);
+        else {
+          // CHARACTER ONLY (§ 3a): a soul that names a permission or a task changes nothing, and a
+          // reader may think it did. Said, not refused: the words may be innocent.
+          const soul = readText(soulFile);
+          if (/\b[a-z]+:(read|write|read-all|manage|author|publish)\b|unoverse:\/\/tasks\//.test(soul)) {
+            report("warn", rel(soulFile), `agent ${name}: the soul names a permission or a task. A soul is character only: put access and tasks in agent.yaml`);
+          }
+        }
+      }
+      // Each task's URI names a task of the org: an app, template, component or pipeline folder.
+      // A workflow's Task Start is named on its canvas, not here, so one not found is a hint.
+      const own = new Set(["apps", "templates", "components", "pipelines"].flatMap((k) => foldersIn(tier.dir, k)));
+      const mcpNodes = marketplaceMcps();
+      for (const uri of Array.isArray(doc.tasks) ? doc.tasks : []) {
+        const m = /^unoverse:\/\/tasks\/([a-z0-9][a-z0-9-]*)\/([A-Za-z0-9][A-Za-z0-9._-]*)$/.exec(String(uri));
+        if (!m) continue;
+        if (m[1] !== tier.org && m[1] !== "marketplace") report("error", at, `agent ${name}: task ${uri} belongs to another org; an Agent calls its own org's tasks and the marketplace's`);
+        // A MARKETPLACE MCP IS A TASK (MCP_TASKS.md § 2a): its name is a node type in kebab case.
+        else if (m[1] === "marketplace" && mcpNodes && !mcpNodes.has(m[2])) report("error", at, `agent ${name}: task ${uri} is not a marketplace MCP; one is a node that offers MCP tools, by its type in kebab case (signal-save, spatial-search)`);
+        else if (m[1] === tier.org && !own.has(m[2])) report("hint", at, `agent ${name}: task ${uri} is not an app, template, component or pipeline here; if it is a workflow's Task Start, check its Name on the canvas`);
+      }
+      const nodes = visibleNodes(tier);
+      for (const ch of Array.isArray(doc.triggers) ? doc.triggers : []) {
+        if (!isRecord(ch)) continue;
+        if (ch.name === "spatial") {
+          if (ch.node) report("error", at, `agent ${name}: the spatial trigger names no node; the Agent is found in its org's Spatial`);
+          continue;
+        }
+        if (!ch.node) report("error", at, `agent ${name}: trigger ${ch.name} names no node`);
+        else if (nodes && !nodes.has(ch.node)) report("error", at, `agent ${name}: trigger ${ch.name} names node ${ch.node}, which is not a node here`);
+      }
+      if (!Array.isArray(doc.tasks) || doc.tasks.length === 0) report("error", at, `agent ${name}: it has no tasks, so it can do nothing`);
+    }
+  }
+
+  /**
+   * ONE NAME PER TASK IN AN ORG (docs/mcp/MCP_TASKS.md § 2a, U9). Every task is
+   * `unoverse://tasks/<org>/<name>`, whatever it is built from, so two assets of an org may not
+   * share a name. The one exception is the usual one: an app and the template or component it
+   * wraps share its name, and the app is the task. A workflow's Task Start is named on its canvas,
+   * not in these folders, so it is not seen here.
+   */
+  for (const tier of tiers) {
+    if (!tier.org) continue;
+    const kinds = new Map();
+    for (const kind of ["apps", "templates", "components", "pipelines"]) {
+      for (const n of foldersIn(tier.dir, kind)) kinds.set(n, [...(kinds.get(n) ?? []), kind]);
+    }
+    for (const [n, list] of kinds) {
+      if (list.length < 2) continue;
+      const wrapped = list.includes("apps") && list.length === 2 && (list.includes("templates") || list.includes("components"));
+      if (wrapped) continue;
+      report(
+        "error",
+        rel(join(tier.dir, list[0], n)),
+        `task ${tier.org}/${n}: ${list.join(" and ")} share one name, and a task's name is unique in its org (unoverse://tasks/${tier.org}/${n}). Rename one.`,
+      );
+    }
+  }
+
   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, objectCount, pipelineCount, designRoot: ROOT };
+  return { problems: sorted, objectCount, pipelineCount, agentCount, designRoot: ROOT };
 }
 
 /** True when anything would fail a build. Warnings and hints inform, errors stop. */

package/vendor/base/src/lint/objects/rules.d.mts

@@ -31,6 +31,9 @@ export function objectTestFindings(name: string, test: unknown, service: unknown
 /** The words a `make` block says about its read; every other key is an object that read makes. */
 export const PIPELINE_READ_KEYS: Set<string>;
 export function pipelineFindings(name: string, file: unknown, fileName?: string): RuleFinding[];
+/** A layout names no document (document-map.md, 2026-10-21): refuses a fund's, a firm's or a ticker's name, and lists of names. */
+export function layoutFindings(name: string, file: unknown, fileName?: string): RuleFinding[];
+export const LAYOUT_VOCABULARY: Set<string>;
 export function collectRefs(value: unknown): Set<string>;
 export function configRefs(value: unknown): Set<string>;
 export function pipelineFolderFindings(

package/vendor/base/src/lint/objects/rules.mjs

@@ -29,7 +29,9 @@ export const ELEMENTS = new Set(["purpose", "story", "content", "capability", "p
 export const FACE_KEYS = ["title", "description", "whenToUse", "category", "version"];
 
 /** The prop grammar of UNOVERSE_AUTHORING 3b plus the object's one word, `from` (README 4c). */
-export const PROP_KEYS = new Set(["type", "input", "description", "from", "hydrate", "enum", "oneOf", "minLength", "maxLength", "minItems", "maxItems", "items", "reuse"]);
+// `none` IS NO DEFAULT (2026-10-15): it is what a cell that STATES there is none ("None", "N/A") stands for, so a
+// stated "no performance fee" is 0 and a fee nobody states stays empty.
+export const PROP_KEYS = new Set(["type", "input", "description", "from", "hydrate", "enum", "oneOf", "minLength", "maxLength", "minItems", "maxItems", "items", "reuse", "answeredBy", "standard", "wordings", "wordingsIn", "onlyWith", "format", "pattern", "none"]);
 export const LIMIT_KEYS = ["minLength", "maxLength", "minItems", "maxItems"];
 
 /** Words that left the object grammar and must not come back (README 11.7, 12.3, 12.4). */
@@ -96,7 +98,9 @@ export function envelopeFindings(name, envelope, file = `${name}.yaml`) {
         if (pairs.length !== 1 || pairs.some(([a, b]) => typeof a !== "string" || typeof b !== "string" || !a || !b)) refuse(`object ${name}: link ${ln}: match is one pair, this row's field naming that row's ({ manager: legalName })`);
         if (l.between != null || l.order != null) refuse(`object ${name}: link ${ln}: a line to another object says to and match, never between or order`);
         if (l.alike != null && (!Array.isArray(l.alike) || l.alike.some((f) => typeof f !== "string" || !pairs.some(([a]) => a === f)))) refuse(`object ${name}: link ${ln}: alike lists this row's match field whose value may name one thing several ways`);
-        for (const k of Object.keys(l)) if (!["type", "to", "match", "when", "alike"].includes(k)) say(`object ${name}: link ${ln}: "${k}" is not a word here`);
+        // WHAT A LINE CARRIES (relationships-and-labels.md, 2026-10-14) is fields of this row, by name.
+        if (l.carries != null && (!Array.isArray(l.carries) || l.carries.some((f) => typeof f !== "string" || !f))) refuse(`object ${name}: link ${ln}: carries lists fields of this row each line keeps ([role])`);
+        for (const k of Object.keys(l)) if (!["type", "to", "match", "when", "alike", "carries"].includes(k)) say(`object ${name}: link ${ln}: "${k}" is not a word here`);
         continue;
       }
       if (!Array.isArray(l.between) || !l.between.length || l.between.some((f) => typeof f !== "string")) refuse(`object ${name}: link ${ln}: between is a list of the fields whose equal values make one line of rows`);
@@ -116,8 +120,10 @@ export function envelopeFindings(name, envelope, file = `${name}.yaml`) {
       for (const k of ["ids", "evidence", "ruleOut"]) if (m[k] != null && !fields(m[k])) refuse(`object ${name}: matching: ${k} is a list of field names`);
       if (m.createFrom != null && !fields(m.createFrom)) refuse(`object ${name}: matching: createFrom is a list of line names (about)`);
       if (m.remember != null && (typeof m.remember !== "string" || !(m.names ?? []).includes(m.remember))) refuse(`object ${name}: matching: remember names one of names, the list a confirmed name is added to`);
-      if (m.judge != null && (typeof m.judge !== "string" || !/^[A-Z][A-Za-z0-9]*$/.test(m.judge))) refuse(`object ${name}: matching: judge names a node by its type (TypeSafeChoice)`);
-      for (const k of Object.keys(m)) if (!["ids", "names", "remember", "evidence", "ruleOut", "judge", "createFrom"].includes(k)) say(`object ${name}: matching: "${k}" is not a word here`);
+      // A JUDGE IS A NODE BY ITS TYPE, OR A DECISION NODE WITH ITS CONFIG as `review` is ({ node: OpenAIDecision, config: { model } }).
+      const judgeNode = isRecord(m.judge) ? m.judge.node : m.judge;
+      if (m.judge != null && (typeof judgeNode !== "string" || !/^[A-Z][A-Za-z0-9]*$/.test(judgeNode) || (isRecord(m.judge) && m.judge.config != null && !isRecord(m.judge.config)))) refuse(`object ${name}: matching: judge names a node by its type (TypeSafeChoice), or a decision node with its config ({ node: OpenAIDecision, config: { model } })`);
+      for (const k of Object.keys(m)) if (!["ids", "names", "remember", "evidence", "ruleOut", "judge", "link", "review", "createFrom"].includes(k)) say(`object ${name}: matching: "${k}" is not a word here`);
     }
   }
   return out;
@@ -158,6 +164,29 @@ export function propsFindings(name, ownProps, parentProps = null, base = null, f
       if (raw.enum != null) say(`object ${name}: prop "${k}" says both enum and oneOf; one or the other`);
     }
     if (raw.type === "array" && !isRecord(raw.items)) say(`object ${name}: prop "${k}" is an array and carries no items: an array says the shape of one element, in the same grammar one level down (README 4c)`);
+    if (raw.answeredBy != null && (!Array.isArray(raw.answeredBy) || !raw.answeredBy.length || raw.answeredBy.some((d) => typeof d !== "string" || !d.trim()))) say(`object ${name}: prop "${k}": answeredBy is a list of the document kinds that may answer it, e.g. [offering-memorandum, side-letter]`);
+    if (raw.answeredBy != null && raw.input !== true) say(`object ${name}: prop "${k}" says answeredBy but not input: true; only a field read from documents is answered by one`);
+    // A FIELD A TABLE CAN FILL (pipelines/tables.md, 2026-10-12): `standard` is its id in the org's
+    // field list, `wordings` the words documents print for it, matched exactly after lower case.
+    if (raw.standard != null && (typeof raw.standard !== "string" || !raw.standard.trim())) say(`object ${name}: prop "${k}": standard is the field's id in the org's field list, one word (OFST452010)`);
+    if (raw.wordings != null && (!Array.isArray(raw.wordings) || !raw.wordings.length || raw.wordings.some((w) => typeof w !== "string" || !w.trim()))) say(`object ${name}: prop "${k}": wordings is a list of the words documents print for this field, e.g. [management fee, mgmt fee]`);
+    if (raw.pattern != null) { try { if (typeof raw.pattern !== "string" || !raw.pattern.trim()) throw 0; new RegExp(raw.pattern); } catch { say(`object ${name}: prop "${k}": pattern is the regular expression a value must match, e.g. ^[A-Z]{2}[A-Z0-9]{9}[0-9]$; a value that does not match is never saved`); } }
+    if (raw.format != null && raw.format !== "date" && raw.format !== "country") say(`object ${name}: prop "${k}": format is date, country, or nothing (a date is written yyyy-mm-dd; a country is held by its one name from ISO 3166, "UK" saved as United Kingdom)`);
+    // A WORDING SCOPED TO ONE KIND OF DOCUMENT (2026-10-26): `wordingsIn` lists, under a document type, the words that name
+    // this field in that type only, where one type prints for this field the words another prints for another field.
+    if (raw.wordingsIn != null && (!isRecord(raw.wordingsIn) || !Object.keys(raw.wordingsIn).length || Object.values(raw.wordingsIn).some((ws) => !Array.isArray(ws) || !ws.length || ws.some((w) => typeof w !== "string" || !w.trim())))) say(`object ${name}: prop "${k}": wordingsIn lists, under each document type, the words that name this field in that type only, as { <document type>: [<words>] }`);
+    if (raw.wordingsIn != null && raw.input !== true) say(`object ${name}: prop "${k}" says wordingsIn but not input: true; only a field read from documents is filled from a table`);
+    // A TERM OF ANOTHER FIELD (2026-10-26): `onlyWith` names the field this one is a term of; where that field is none,
+    // this one is not kept.
+    if (raw.onlyWith != null && (typeof raw.onlyWith !== "string" || raw.onlyWith === k || !(raw.onlyWith in ownProps || (parentProps && raw.onlyWith in parentProps)))) say(`object ${name}: prop "${k}": onlyWith names another field of this object that this one is a term of, and is kept only where that field is not none`);
+    if ((raw.standard != null || raw.wordings != null) && raw.input !== true) say(`object ${name}: prop "${k}" says standard or wordings but not input: true; only a field read from documents is filled from a table`);
+  }
+  // FILLED FROM DOCUMENTS, EVERY FIELD SAYS WHICH (proved-before-built.md, ruled 2026-10-07): an
+  // object one of whose fields names the documents that answer it is filled from documents, so
+  // every field it reads names them; a field without would never be asked.
+  const own = Object.entries(ownProps).filter(([k, raw]) => isRecord(raw) && !(parentProps && k in parentProps));
+  if (own.some(([, raw]) => raw.answeredBy != null)) {
+    for (const [k, raw] of own) if (raw.input === true && raw.answeredBy == null) say(`object ${name}: prop "${k}" is input: true and says no answeredBy; on an object filled from documents every field read names the documents that answer it, or nothing ever asks for it`);
   }
   return out;
 }
@@ -304,7 +333,7 @@ export const PIPELINE_READ_KEYS = new Set(["each", "sourceUrl", "sourceId", "con
 const DROPPED_MAKE_KEYS = ["partsOf", "by", "under", "when", "from", "any", "index"];
 
 /** What an object may say: under `each`, how many and what it holds; made once per pack, how many and from which rows. */
-const ITEM_OBJECT_KEYS = new Set(["cardinality", "any", "parts", "where", "per"]);
+const ITEM_OBJECT_KEYS = new Set(["cardinality", "any", "parts", "where", "per", "read", "tables"]);
 const FIELD = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 /**
@@ -381,8 +410,14 @@ export function pipelineFindings(name, file, fileName = "pipeline.yaml") {
         }
         if (made.includes(o)) refuse(`pipeline ${name}: ${at}.${o} is made above already; one entry makes an object`);
         const allowed = ITEM_OBJECT_KEYS;
-        for (const k of Object.keys(spec)) if (!allowed.has(k)) refuse(`pipeline ${name}: ${at}.${o}: "${k}" is not a word here; an object says cardinality, any, parts, where and per (${see})`);
-        if ("per" in spec && spec.per !== "section") refuse(`pipeline ${name}: ${at}.${o}: per says section, the only unit an object is written per (${see})`);
+        for (const k of Object.keys(spec)) if (!allowed.has(k)) refuse(`pipeline ${name}: ${at}.${o}: "${k}" is not a word here; an object says cardinality, any, parts, where, per, read and tables (${see})`);
+        if ("tables" in spec && (!isRecord(spec.tables) || ("whose" in spec.tables && (!isRecord(spec.tables.whose) || typeof spec.tables.whose.node !== "string" || !spec.tables.whose.node)))) refuse(`pipeline ${name}: ${at}.${o}: tables is a record; its whose names the node that says which row a table is about: tables: { whose: { node: OpenAIDecision, config: { ... } } } (pipelines/tables.md)`);
+        if (isRecord(spec.tables) && "labels" in spec.tables && (!isRecord(spec.tables.labels) || typeof spec.tables.labels.node !== "string" || !spec.tables.labels.node)) refuse(`pipeline ${name}: ${at}.${o}: tables.labels names the node that proposes a field for a label no rule matched: tables: { labels: { node: OpenAIDecision, config: { ... } } } (pipelines/tables.md)`);
+        if (isRecord(spec.tables) && "allocations" in spec.tables && (typeof spec.tables.allocations !== "string" || !spec.tables.allocations)) refuse(`pipeline ${name}: ${at}.${o}: tables.allocations names the line an allocation table draws to each fund it holds: tables: { allocations: allocatesTo } (pipelines/tables.md 3c)`);
+        if (isRecord(spec.tables) && "boards" in spec.tables && (!Array.isArray(spec.tables.boards) || !spec.tables.boards.length || !spec.tables.boards.every((b) => typeof b === "string" && b))) refuse(`pipeline ${name}: ${at}.${o}: tables.boards names the lines a board list may draw, each to whose board it is: tables: { boards: [directorOf, worksAt] } (pipelines/tables.md 3d)`);
+        if ("read" in spec && (!isRecord(spec.read) || typeof spec.read.node !== "string" || !spec.read.node)) refuse(`pipeline ${name}: ${at}.${o}: read names the node that reads the pages: read: { node: BeamEndpoint, config: { ... } } (${see})`);
+        if ("read" in spec && spec.per !== "page") refuse(`pipeline ${name}: ${at}.${o}: read is how an object written per page is read; say per: page beside it (${see})`);
+        if ("per" in spec && spec.per !== "page") refuse(`pipeline ${name}: ${at}.${o}: per says page, the only unit an object is written per; there are no sections (page-store.md) (${see})`);
         // HOW MANY IS SAID by every object the model writes (owner, 2026-09-13).
         if (spec.cardinality !== "one" && spec.cardinality !== "many") say(`pipeline ${name}: ${at}.${o} says cardinality: one or many, how many of it one row makes (${see})`);
         if ("any" in spec && spec.any !== true) refuse(`pipeline ${name}: ${at}.${o}: any: true is its only value, the item MAY be one`);
@@ -456,6 +491,70 @@ export function pipelineFolderFindings(name, { file, config, test }, { nodeTypes
 }
 
 /** The first error's message. */
+// ── Layouts ─────────────────────────────────────────────────────────────────────────────────────────
+/**
+ * A LAYOUT NAMES NO DOCUMENT (docs/unoverse/data/pipelines/document-map.md, owner 2026-10-21, seeing a
+ * draft carry "EAM B.V." and "TL-X"). A layout is the map of a document TYPE: it speaks in the type's
+ * structure and wording, never in a fund's, a firm's, an index's or a ticker's name. Names belong on
+ * records. Refused here, so a layout that fits one house's documents is never loaded.
+ */
+/** A legal form as one word of a name, in any jurisdiction's spelling: the mark of a firm's or a fund's name. */
+const LEGAL_FORM_WORD = /^(?:Ltd|Limited|LLC|LLP|L\.?P\.?|LP|plc|PLC|Inc\.?|Corp\.?|Co\.?|GmbH|AG|S\.?A\.?|S\.?C\.?A\.?|S\.?p\.?A\.?|SpA|B\.?V\.?|BV|N\.?V\.?|NV|S\.?à\.?r\.?l\.?|SARL|Sàrl|Pte\.?|Pty\.?|KGaA|KG|ApS|AB|AS|Oy|SE|SAS|SL|SRL|Srl|V)\.?$/;
+const LAYOUT_TEXT_KEYS = new Set(["pattern", "after", "heading", "text", "row", "table", "say", "describe", "trim", "split"]);
+const LAYOUT_NAME_KEYS = new Set(["names", "sameAs", "neverMerge", "aliases"]);
+/** Every capitalised run of two or more words in a string, regex syntax and escapes aside. */
+function capitalisedRuns(str) {
+  // Regex syntax is not words: character classes, counts, escapes and group openers go before the words are read.
+  const plain = String(str).replace(/\(\?<?[!=][^)]*\)/g, " ").replace(/\[[^\]]*\]/g, " ").replace(/\{[^}]*\}/g, " ").replace(/\\[A-Za-z]/g, " ").replace(/\(\?[:!=<]?/g, " ").replace(/[\[\]()|^$?*+{}.\\]/g, " ").replace(/\s+/g, " ");
+  return [...plain.matchAll(/(?:\b[A-Z][\w'&.-]*(?: (?:of|de|di|du|des|and|&) )?\s?){2,}/g)].map((m) => m[0].trim()).filter((r) => r.split(/\s+/).length >= 2);
+}
+/** A ticker or an identifier spelled out: letters and digits run together ("LU0000000000", "ABCDEF LX", "X1AA"), or an ISIN shape. */
+const LITERAL_CODE = /\b(?:[A-Z]{2}[A-Z0-9]{9}\d|[A-Z]{4,}\s[A-Z]{2}|[A-Z]+\d+[A-Z]+|TL-[A-Z]\d*)\b/;
+/**
+ * The same inside a finder that reads any case (`case: any`, 2026-10-24): there capitals are the type's wording as printed
+ * ("A SUB-FUND OF THE"), so a word of four capitals then one of two is a ticker only when the two stand alone ("ABCDEF LX");
+ * a code with digits or an identifier's shape is refused as everywhere.
+ */
+const LITERAL_CODE_ANY_CASE = /\b(?:[A-Z]{2}[A-Z0-9]{9}\d|[A-Z]+\d+[A-Z]+|TL-[A-Z]\d*)\b|(?<![A-Za-z][\s-]?)\b[A-Z]{4,}\s[A-Z]{2}\b(?![\s-]?[A-Za-z])/;
+export function layoutFindings(name, file, fileName = `${name}.yaml`) {
+  const out = [];
+  const refuse = (msg) => out.push({ file: fileName, msg, refuses: true });
+  if (!isRecord(file)) return [{ file: fileName, msg: `layout ${name}: ${fileName} must be a record`, refuses: true }];
+  const walk = (v, path, anyCase = false) => {
+    if (Array.isArray(v)) { v.forEach((x, i) => walk(x, `${path}[${i}]`, anyCase)); return; }
+    if (isRecord(v)) {
+      // A FINDER THAT READS ANY CASE (`case: any`): its own strings are wording, capitals and all; a record beneath it is its own.
+      const own = v.case === "any";
+      for (const [k, x] of Object.entries(v)) {
+        if (LAYOUT_NAME_KEYS.has(k)) refuse(`layout ${name}: "${k}" at ${path} lists names; a layout names no document, aliases live on records (document-map.md, 2026-10-21)`);
+        else if (k === "map" && isRecord(x)) { for (const [from, to] of Object.entries(x)) for (const t of [from, String(to)]) check(t, `${path}.map`); }
+        else walk(x, path ? `${path}.${k}` : k, own && typeof x === "string");
+      }
+      return;
+    }
+    if (typeof v === "string") { const key = path.split(/[.[]/).pop()?.replace("]", ""); if (LAYOUT_TEXT_KEYS.has(key)) check(v, path, anyCase); }
+  };
+  const check = (str, path, anyCase = false) => {
+    // BY STRUCTURE, NEVER BY A WORD LIST (owner 2026-10-24: a list of a document type's words grew from one org's documents).
+    // A name shows itself two ways: a capitalised run that ends in a legal form and holds a word that is not one
+    // ("Example Asset Management B.V."; an alternation of legal forms alone is pattern syntax), and a `never` pattern that
+    // is plain words with no regular-expression structure, which can only be one name. Wording a pattern matches or maps
+    // ("No Distribution", "Swiss Paying Agent") is the type's own and carries no name.
+    const plain = String(str).replace(/\\[A-Za-z]/g, " ");
+    for (const run of capitalisedRuns(plain)) {
+      const words = run.split(/\s+/).filter(Boolean);
+      const last = words[words.length - 1] ?? "";
+      // A lone capital letter is a legal form's initial once its dots are gone ("S A", "B V"), never a word of a name.
+      const ownWords = words.filter((w) => !LEGAL_FORM_WORD.test(w) && !/^[A-Z]$/.test(w) && !/^(?:of|de|di|du|des|and|&)$/i.test(w));
+      if (LEGAL_FORM_WORD.test(last) && ownWords.length >= 1) refuse(`layout ${name}: "${run}" at ${path} reads like a name (a legal form ends it); a layout names no document (document-map.md, 2026-10-21)`);
+    }
+    if (/(^|\.)never\[\d+\]\.pattern$/.test(path) && !/[\\^$.*+?()[\]{}|]/.test(str) && /[A-Z]/.test(str)) refuse(`layout ${name}: "${str.slice(0, 60)}" at ${path} reads like a name (plain words with no structure); a never rule is structural (document-map.md, 2026-10-21)`);
+    if ((anyCase ? LITERAL_CODE_ANY_CASE : LITERAL_CODE).test(str.replace(/\[[^\]]*\]|\{[^}]*\}|\\[A-Za-z]/g, " "))) refuse(`layout ${name}: "${str.slice(0, 60)}" at ${path} spells out a code or ticker; a layout names no document (document-map.md, 2026-10-21)`);
+  };
+  walk(file, "");
+  return out;
+}
+
 export function firstError(findings) {
   const f = findings.find((x) => !x.level || x.level === "error");
   return f ? f.msg : null;

package/vendor/base/src/manifests/compose.ts

@@ -586,6 +586,9 @@ export function composeNode(raw: RawNode, pkg: RawPackage): ComposedNode {
       attaches: iface.attaches ?? null,
       visibility: node.visibility ?? "public",
       capabilities: node.capabilities ?? null,
+      // HOW THE SERVICE PROVES A MESSAGE IS ITS OWN (docs/auth-security/INBOUND.md § 2 step 3): a
+      // scheme the platform verifies, and the credential field holding the secret. Null: it sends none.
+      inbound: node.inbound ?? null,
       inputs: iface.inputs ?? [],
       outputs: iface.outputs ?? [],
       credentials: iface.credentials ?? [],

package/vendor/base/src/manifests/executor/callback.ts

@@ -6,7 +6,7 @@ import { contextFor } from "./context.js";
 import { sessionFor, stateStoreFor, audioLaneFor } from "./session.js";
 import { refireAfterDocMutation } from "./refire.js";
 import { toolBridgeFor } from "./toolBridge.js";
-import { hydrateMemory, ingestMemoryTurn, sessionTurnRecorder } from "./memory.js";
+import { hydrateMemory, hydrateOpenedTask, ingestMemoryTurn, sessionTurnRecorder } from "./memory.js";
 
 export class ManifestCallbackExecutor {
   logger: any = console;
@@ -69,7 +69,8 @@ export class ManifestCallbackExecutor {
     // A SESSION is a run that holds a socket for the length of a call: the block rides the
     // replayed history instead of a prompt, and turns are saved as they complete (below).
     const session = Array.isArray(node.api?.run) && node.api.run.some((r: any) => r?.transport === "ws");
-    const hydratedConfig = await hydrateMemory(event.config, executionContext ?? this.executionContext, { session });
+    const memoryConfig = await hydrateMemory(event.config, executionContext ?? this.executionContext, { session });
+    const hydratedConfig = session ? await hydrateOpenedTask(memoryConfig, executionContext ?? this.executionContext) : memoryConfig;
     const ctx = contextFor(node, event.inputs, hydratedConfig, executionContext ?? this.executionContext);
     const turns = session ? sessionTurnRecorder(node.type, event.config, executionContext ?? this.executionContext) : null;