@unoverse-platform/studio 0.1.116 → 0.1.117

package/vendor/base/src/definitions/load/expand/refs.ts

@@ -83,7 +83,7 @@ function applyStyleLiterals(style: unknown, lits: Record<string, unknown>): void
 
 export function applyLiterals(node: AnyNode, lits: Record<string, unknown>): void {
   // A NESTED REF FORWARDS THE LITERAL. A piece whose kind is itself a Ref to an atom
-  // (SAB's button: primary = the marketplace `button` atom with `props: {label: label}`)
+  // (a bank's button: primary = the marketplace `button` atom with `props: {label: label}`)
   // hands its host's literal on as that Ref's `with`, so the atom draws the words whether
   // the tree is expanded here or resolved by name on the client (referenced form).
   if (node.type === "Ref" && node.props && typeof node.props === "object") {

package/vendor/base/src/definitions/load/expand/walk.ts

@@ -61,7 +61,7 @@ export function expandNode(node: AnyNode, contextOrg?: string, inherit?: Record<
  * silently resolved to the marketplace `button` atom and the org's own button component
  * was never reached (2026-09-07). A bare name keeps the old order: atom first.
  *
- * AN EMBEDDED PIECE'S PRIVATE AXIS IS CHOSEN WHERE IT IS COMPOSED (2026-09-07, the SAB
+ * AN EMBEDDED PIECE'S PRIVATE AXIS IS CHOSEN WHERE IT IS COMPOSED (2026-09-07, the a bank
  * button: kinds primary/secondary/outline/link on a private `kind` axis). Its root is the
  * compiled surface shell around the switches on that axis. Inlined, the piece has no slice
  * of its own, so the host's `with` names the kind, and a host that names none gets the

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

@@ -37,7 +37,7 @@ export interface AgentFolder {
   version?: string;
   avatar?: string;
   skills: string[];
-  model?: { use?: string; reasoning?: string; fallback?: string };
+  model?: { use?: string; reasoning?: string; fallback?: string; turns?: number };
   budget?: { perDay?: string; perRun?: string };
   tasks: string[];
   access: string[];
@@ -79,7 +79,7 @@ export function readAgentFolder(root: string, org: string, name: string): AgentF
     version: str(doc.version),
     avatar: str(doc.avatar),
     skills: strs(doc.skills),
-    ...(model ? { model: { use: str(model.use), reasoning: str(model.reasoning), fallback: str(model.fallback) } } : {}),
+    ...(model ? { model: { use: str(model.use), reasoning: str(model.reasoning), fallback: str(model.fallback), ...(typeof model.turns === "number" && model.turns > 0 ? { turns: Math.floor(model.turns) } : {}) } } : {}),
     ...(budget ? { budget: { perDay: str(budget.perDay), perRun: str(budget.perRun) } } : {}),
     tasks: strs(doc.tasks),
     access: strs(doc.access),

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

@@ -290,7 +290,7 @@ export function loadAppManifest(ref: string): AppManifest | null {
   // the template loader); the app loader never did, so `app.previewComponents?.[0]`
   // was undefined and the app tool's whole render block — gated on that ref — was
   // skipped. The call returned cleanly, nothing reached /stream, and the model told
-  // the person to use a surface that had never appeared (SAB sab-voice, 2026-09-07).
+  // the person to use a surface that had never appeared (a bank's voice app, 2026-09-07).
   // `kind` rides along for the same reason it does on a template: the render path
   // resolves the definition in the tier `kind` names, and an app is not a component.
   return normalizeMode({

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

@@ -94,6 +94,8 @@ export interface ObjectLink {
   match?: Record<string, string>;
   /** Fields (of `between`, or the row's side of `match`) whose values may name one thing several ways: one question per set of names says which are the same. */
   alike?: string[];
+  /** Fields of the row this line carries, added never replaced: a provider's `serves` carries its role (relationships-and-labels.md). */
+  carries?: string[];
 }
 
 /**
@@ -112,8 +114,9 @@ export interface ObjectMatching {
   evidence?: string[];
   /** Filled on both and different, as words: never the same thing. */
   ruleOut?: string[];
-  /** The node that decides a name the rules leave open (TypeSafeChoice). Absent, an open name goes to review. */
-  judge?: string;
+  /** The node that decides a name the rules leave open: a node's name (TypeSafeChoice), or a decision node with its
+   *  config ({ node: OpenAIDecision, config: { model } }), asked as the review is. Absent, an open name goes to review. */
+  judge?: string | { node: string; config?: Record<string, unknown> };
   /**
    * THE LINKER, BEFORE THE JUDGE (pipelines README, "Three sweeps"; owner 2026-10-10: "Splink to dedupe
    * our entities"): a node that scores the name against each candidate's names. Sure the same, it links;
@@ -129,6 +132,8 @@ export interface ObjectMatching {
   review?: { node: string; config?: Record<string, unknown> };
   /** The lines (by name, e.g. a document's `about`) whose name, sure to be no record held, makes the record. A mention on any other line never does. */
   createFrom?: string[];
+  /** The object's `extract.never` words, set by the registry: left out when two names of one parent are compared ("A Shares" and "Class A"). */
+  never?: string[];
 }
 
 /**
@@ -143,6 +148,18 @@ export interface DatasetColumn {
    *  its words here and the database refuses the rest: a misspelling cannot become a second
    *  thing that never sums with the first. Absent on a column carrying a document's own words. */
   enum?: string[];
+  /** FOR A COLUMN WITH `enum`: the words a table's title or headings print for each value (net return:
+   *  [performance, returns]), so a table found by its shape is known by what it holds (tables.md 3b). */
+  wordings?: Record<string, string[]>;
+  /** FOR A COLUMN WITH `enum`: the words a key-figures row's own label prints for each value (net asset
+   *  value: [total net assets, fund size]), so "Total Net Assets | USD 126m" is one figure (tables.md 3b). */
+  rowWordings?: Record<string, string[]>;
+  /** FOR A COLUMN WITH `enum`: the words a table's COLUMN prints for each value (exposure: [market value, % of net
+   *  assets]), so a number kept from any table is known by the column it sits under (tables.md 3f, 2026-10-16). */
+  columnWordings?: Record<string, string[]>;
+  /** FOR A COLUMN WITH `enum`: the values of another column each of its values gathers (dimension fair value level:
+   *  [Level 1, Level 2, Level 3]), so a number whose row or column names one is known to be sliced that way (tables.md 3i). */
+  values?: Record<string, string[]>;
   /** string | number | integer | date | datetime | boolean. Nothing else: a type this does not
    *  name is one the generated table cannot promise anything about. */
   type: string;
@@ -165,6 +182,35 @@ export interface DatasetDefinition {
   subject?: string;
   asOf?: string;
   description?: string;
+  /** WHOSE A ROW IS, AS RECORDS (tables.md 3i step 4, 2026-10-17: the code names no industry): the object a row's subject is,
+   *  its parts, how one sits inside another, and the `level` values each is filed under. Absent: rows name no record. */
+  whose?: DatasetWhose;
+}
+
+export interface DatasetWhose {
+  /** The object a row's subject is (a fund), the column its name goes in, the `level` value for its own figures. */
+  object: string; column: string; level: string;
+  /** The subject's field of other names, the field naming what it is compared with (its index), and the `level` value for that. */
+  names?: string; compare?: string; compareLevel?: string;
+  /** How a subject sits inside another: the link from it to its parent, and the field naming the parent. */
+  within?: { link: string; field?: string };
+  /** Its parts (a fund's share classes): their object, their column, their `level` value, their name field, and the field naming their subject. */
+  part?: { object: string; column: string; level: string; name: string; of: string; measures?: string[]; perUnit?: Record<string, string> };
+  /** The subject's own measures: a figure of one is the subject's, over a part only its section named. */
+  measures?: string[];
+  /** The measures that are a record's standing terms (a fee rate): a figure of one is a field, never a row. */
+  terms?: string[];
+  /** The measures that are a subject's figure against its comparison (an excess return): a row of one that names no
+   *  subject is the subject the table's own rows name, when they name exactly one. */
+  relative?: string[];
+  /** The words a name of the subject's kind carries (fund, portfolio): an allocation's row naming one, with words of its
+   *  own, is a holding (tables.md 3c rule 3). Absent, the word fund. */
+  vehicles?: string[];
+  /** Who stands behind the subject (a fund's manager): its object, as a layout's section names it in `about`, and the
+   *  `level` value for its figures (the firm's assets under management), reached from a row's subject by a join. */
+  owner?: { object: string; level: string };
+  /** The `level` value for a document about no subject (a market note). */
+  none?: string;
 }
 
 export interface ObjectFunction {
@@ -220,7 +266,7 @@ export interface ObjectDefinition {
   /** How a name is matched to its rows (entity-resolution.md); absent, a line to it compares one field with one field. */
   matching?: ObjectMatching;
   /** How a page reader picks it out of a page (pipelines README, "Or read by a node"): instructions and worked examples. */
-  extract?: { instructions?: string; examples?: { text: string; answer: Record<string, unknown>[] }[]; never?: string[] };
+  extract?: { instructions?: string; examples?: { text: string; answer: Record<string, unknown>[] }[]; never?: string[]; notAlso?: string[]; notAlsoWhen?: Record<string, Record<string, string[]>>; notWhen?: string[] };
   /** THE TABLE THIS OBJECT OWNS (docs/unoverse/data/objects/dataset.md, PROPOSED 2026-09-18),
    *  from its folder's table.yaml: an object that holds many small facts read together rather
    *  than one row read alone. Absent on every ordinary object, which stays a row. */
@@ -290,12 +336,54 @@ export function readDataset(name: string, file: Record<string, any>, dir: string
     // about the column.
     if (allowed && type !== "string") findings.push(`column "${col}": only a string column may say which values it allows`);
     if (allowed && new Set(allowed).size !== allowed.length) findings.push(`column "${col}": its allowed values repeat`);
-    columns.push({ name: col, type, ...(allowed ? { enum: allowed } : {}), ...(c?.required === true ? { required: true } : {}), ...(c?.indexed === true ? { indexed: true } : {}), ...(c?.description ? { description: String(c.description) } : {}) });
+    // ITS WORDS (tables.md 3b): what a table prints for each allowed value; a key outside the list is no word of it.
+    const wordings = c?.wordings && typeof c.wordings === "object" ? Object.fromEntries(Object.entries(c.wordings as Record<string, unknown>).map(([k, v]) => [k, Array.isArray(v) ? v.map(String) : []])) : undefined;
+    if (wordings && !allowed) findings.push(`column "${col}": wordings name the words for allowed values, so the column says enum`);
+    for (const k of Object.keys(wordings ?? {})) if (allowed && !allowed.includes(k)) findings.push(`column "${col}": wordings for "${k}", which is not one of its allowed values`);
+    // AND A ROW'S OWN WORDS (key figures, tables.md 3b): kept like `wordings`, or the reader never sees them
+    // (measured 2026-10-14: dropped here, no key figure was read).
+    const rowWordings = c?.rowWordings && typeof c.rowWordings === "object" ? Object.fromEntries(Object.entries(c.rowWordings as Record<string, unknown>).map(([k, v]) => [k, Array.isArray(v) ? v.map(String) : []])) : undefined;
+    if (rowWordings && !allowed) findings.push(`column "${col}": rowWordings name the words for allowed values, so the column says enum`);
+    for (const k of Object.keys(rowWordings ?? {})) if (allowed && !allowed.includes(k)) findings.push(`column "${col}": rowWordings for "${k}", which is not one of its allowed values`);
+    // AND A COLUMN'S OWN WORDS (every number kept, tables.md 3f): kept like `wordings`.
+    const columnWordings = c?.columnWordings && typeof c.columnWordings === "object" ? Object.fromEntries(Object.entries(c.columnWordings as Record<string, unknown>).map(([k, v]) => [k, Array.isArray(v) ? v.map(String) : []])) : undefined;
+    if (columnWordings && !allowed) findings.push(`column "${col}": columnWordings name the words for allowed values, so the column says enum`);
+    for (const k of Object.keys(columnWordings ?? {})) if (allowed && !allowed.includes(k)) findings.push(`column "${col}": columnWordings for "${k}", which is not one of its allowed values`);
+    // AND THE VALUES EACH OF ITS VALUES GATHERS (a slicing's own values, tables.md 3i): kept like `wordings`.
+    const values = c?.values && typeof c.values === "object" ? Object.fromEntries(Object.entries(c.values as Record<string, unknown>).map(([k, v]) => [k, Array.isArray(v) ? v.map(String) : []])) : undefined;
+    if (values && !allowed) findings.push(`column "${col}": values name what allowed values gather, so the column says enum`);
+    for (const k of Object.keys(values ?? {})) if (allowed && !allowed.includes(k)) findings.push(`column "${col}": values for "${k}", which is not one of its allowed values`);
+    columns.push({ name: col, type, ...(allowed ? { enum: allowed } : {}), ...(wordings ? { wordings } : {}), ...(rowWordings ? { rowWordings } : {}), ...(columnWordings ? { columnWordings } : {}), ...(values ? { values } : {}), ...(c?.required === true ? { required: true } : {}), ...(c?.indexed === true ? { indexed: true } : {}), ...(c?.description ? { description: String(c.description) } : {}) });
   }
   const uniqueBy = Array.isArray(file.uniqueBy) ? file.uniqueBy.map((u: unknown) => String(u)) : undefined;
   for (const u of uniqueBy ?? []) if (!seen.has(u) && !RESERVED.has(u)) findings.push(`uniqueBy names "${u}", which is not a column`);
   if (findings.length) throw new Error(`object ${name}: ${findings.join("; ")} (${dir})`);
-  return { columns, ...(uniqueBy ? { uniqueBy } : {}), ...(file.description ? { description: String(file.description) } : {}) };
+  // WHOSE A ROW IS, AS RECORDS: kept as declared, its columns checked.
+  const w = file.whose && typeof file.whose === "object" ? (file.whose as Record<string, any>) : null;
+  const whose: DatasetWhose | undefined = w && w.object && w.column && w.level ? {
+    object: String(w.object), column: String(w.column), level: String(w.level),
+    ...(w.names ? { names: String(w.names) } : {}), ...(w.compare ? { compare: String(w.compare) } : {}), ...(w.compareLevel ? { compareLevel: String(w.compareLevel) } : {}),
+    ...(w.within?.link ? { within: { link: String(w.within.link), ...(w.within.field ? { field: String(w.within.field) } : {}) } } : {}),
+    // A PART'S OWN MEASURES (2026-10-24): a figure of one of them is always a part's ("net asset value per share" is a
+    // share class's; a fund has no price per share of its own), whatever section it is printed in.
+    ...(w.part?.object ? { part: { object: String(w.part.object), column: String(w.part.column), level: String(w.part.level), name: String(w.part.name), of: String(w.part.of), ...(Array.isArray(w.part.measures) ? { measures: w.part.measures.map(String) } : {}), ...(w.part.perUnit && typeof w.part.perUnit === "object" ? { perUnit: Object.fromEntries(Object.entries(w.part.perUnit).map(([k, v]) => [k, String(v)])) } : {}) } } : {}),
+    ...(w.none ? { none: String(w.none) } : {}),
+    ...(Array.isArray(w.measures) ? { measures: w.measures.map(String) } : {}),
+    // THE MEASURES THAT ARE TERMS (2026-10-25): a figure of one is a field of its record, never a row ("static goes into
+    // the entities, changes over time goes into the metrics").
+    ...(Array.isArray(w.terms) ? { terms: w.terms.map(String) } : {}),
+    // THE MEASURES THAT ARE A FIGURE AGAINST A COMPARISON (2026-10-25): "Excess" printed under a class's and its index's
+    // rows is that class's return above the index, as the measure's own definition says.
+    ...(Array.isArray(w.relative) ? { relative: w.relative.map(String) } : {}),
+    // WHAT A HOLDING OF THE SUBJECT'S KIND IS CALLED IN ITS NAME (tables.md 3c rule 3, 2026-10-26): a fund, a segregated portfolio.
+    ...(Array.isArray(w.vehicles) ? { vehicles: w.vehicles.map(String) } : {}),
+    // WHO STANDS BEHIND THE SUBJECT (2026-10-25): a section about a fund's manager prints the firm's figures, not the fund's.
+    ...(w.owner?.object && w.owner?.level ? { owner: { object: String(w.owner.object), level: String(w.owner.level) } } : {}),
+  } : undefined;
+  if (w && !whose) findings.push("whose names its object, its column and its level");
+  for (const col of [whose?.column, whose?.part?.column].filter(Boolean) as string[]) if (!seen.has(col)) findings.push(`whose names column "${col}", which is not a column`);
+  if (findings.length) throw new Error(`object ${name}: ${findings.join("; ")} (${dir})`);
+  return { columns, ...(uniqueBy ? { uniqueBy } : {}), ...(file.description ? { description: String(file.description) } : {}), ...(whose ? { whose } : {}) };
 }
 
 function readFolder(dir: string, name: string, org: string | undefined, seen: string[]): ObjectDefinition {
@@ -382,7 +470,7 @@ function readFolder(dir: string, name: string, org: string | undefined, seen: st
     ...(typeof envelope.element === "string" && envelope.element ? { element: envelope.element } : parent?.element ? { element: parent.element } : {}),
     ...(envelope.meta ? { meta: envelope.meta } : parent?.meta ? { meta: parent.meta } : {}),
     ...(links && Object.keys(links).length ? { links } : {}),
-    ...(envelope.matching ? { matching: envelope.matching as ObjectMatching } : parent?.matching ? { matching: parent.matching } : {}),
+    ...(envelope.matching ? { matching: { ...(envelope.matching as ObjectMatching), ...((envelope.extract as ObjectDefinition["extract"])?.never?.length ? { never: (envelope.extract as ObjectDefinition["extract"])!.never } : {}) } } : parent?.matching ? { matching: parent.matching } : {}),
     ...(envelope.extract ? { extract: envelope.extract as ObjectDefinition["extract"] } : {}),
     ...(dataset ? { dataset } : {}),
     props,

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

@@ -79,7 +79,17 @@ export interface MakeEntry {
    * object's input props, in place of a model reading every page. Its config is resolved over the
    * run's `config` when the rows are collected.
    */
-  read?: { node: string; config: Record<string, unknown>; chunks?: number | "all" };
+  read?: { node: string; config: Record<string, unknown>; chunks?: number | "all"; cacheable?: true };
+  /**
+   * READ FROM THE DOCUMENT'S TABLES TOO (pipelines/tables.md, 2026-10-12): a table's labels are
+   * matched to the object's props by their `wordings`, and a matched cell's value is copied as
+   * printed. `whose` is the node that says which of the document's rows a table is about, when
+   * the document is linked to more than one. `labels` is the node that proposes a field for a label
+   * no rule matched (column matching step 4), once per org, for a person to approve in Review.
+   */
+  /** `allocations` names the object's line an allocation table draws, one per fund it holds, carrying the weight (tables.md 3c). */
+  /** `boards` names the object's lines a board list may draw, each to whose board it is, carrying the role (tables.md 3d). */
+  tables?: { whose?: { node: string; config: Record<string, unknown> }; subject?: boolean; labels?: { node: string; config: Record<string, unknown> }; allocations?: string; boards?: string[] };
   sourceUrl?: string;
   sourceId?: string;
   /** The item's content, each value a reference over `item`, `index`, `config`, `collect`. */
@@ -162,7 +172,8 @@ function readFolder(dir: string, name: string, org: string | undefined): Pipelin
         ...(spec.cardinality === "one" || spec.cardinality === "many" ? { cardinality: spec.cardinality as "one" | "many" } : {}),
         ...(whenOf(spec) ? { when: whenOf(spec) } : {}),
         ...(spec.per === "page" ? { per: "page" as const } : {}),
-        ...(isRecord(spec.read) && typeof spec.read.node === "string" ? { read: { node: spec.read.node, config: isRecord(spec.read.config) ? spec.read.config : {}, ...(spec.read.chunks === "all" || typeof spec.read.chunks === "number" ? { chunks: spec.read.chunks as number | "all" } : {}) } } : {}),
+        ...(isRecord(spec.read) && typeof spec.read.node === "string" ? { read: { node: spec.read.node, config: isRecord(spec.read.config) ? spec.read.config : {}, ...(spec.read.chunks === "all" || typeof spec.read.chunks === "number" ? { chunks: spec.read.chunks as number | "all" } : {}), ...(spec.read.cacheable === true ? { cacheable: true as const } : {}) } } : {}),
+        ...(isRecord(spec.tables) ? { tables: { ...(isRecord(spec.tables.whose) && typeof spec.tables.whose.node === "string" ? { whose: { node: spec.tables.whose.node, config: isRecord(spec.tables.whose.config) ? spec.tables.whose.config : {} } } : {}), ...(spec.tables.subject === true ? { subject: true } : {}), ...(isRecord(spec.tables.labels) && typeof spec.tables.labels.node === "string" ? { labels: { node: spec.tables.labels.node, config: isRecord(spec.tables.labels.config) ? spec.tables.labels.config : {} } } : {}), ...(typeof spec.tables.allocations === "string" && spec.tables.allocations ? { allocations: spec.tables.allocations } : {}), ...(Array.isArray(spec.tables.boards) && spec.tables.boards.length && spec.tables.boards.every((b: unknown) => typeof b === "string" && b) ? { boards: spec.tables.boards as string[] } : {}) } } : {}),
         sourceUrl: typeof raw.sourceUrl === "string" ? raw.sourceUrl : "{{ item.address }}",
         sourceId: typeof raw.sourceId === "string" ? raw.sourceId : "{{ item.universalId }}",
         content: isRecord(raw.content) ? raw.content : {},

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

@@ -868,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",

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.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);

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", "answeredBy"]);
+// `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,7 +120,9 @@ 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)`);
+      // 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`);
     }
   }
@@ -160,6 +166,20 @@ export function propsFindings(name, ownProps, parentProps = null, base = null, f
     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
@@ -313,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", "read"]);
+const ITEM_OBJECT_KEYS = new Set(["cardinality", "any", "parts", "where", "per", "read", "tables"]);
 const FIELD = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 /**
@@ -390,7 +410,11 @@ 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, per and read (${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})`);
@@ -467,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;