@unoverse-platform/studio 0.1.115 → 0.1.116

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

@@ -114,6 +114,19 @@ export interface ObjectMatching {
   ruleOut?: string[];
   /** The node that decides a name the rules leave open (TypeSafeChoice). Absent, an open name goes to review. */
   judge?: string;
+  /**
+   * 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;
+   * sure different, the name is none of them; between, the judge decides.
+   */
+  link?: { node: string; config: Record<string, unknown> };
+  /**
+   * THE LAST LOOK (owner 2026-10-11: "use the LLM to investigate and solve these"): the node that
+   * looks again at every name a run left open, with what the documents say where it is used
+   * (OpenAIDecision). Sure, it decides as a person would, with Undo; not sure, it stays open.
+   * Absent, the judge looks.
+   */
+  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[];
 }
@@ -206,6 +219,8 @@ export interface ObjectDefinition {
   links?: Record<string, ObjectLink>;
   /** 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[] };
   /** 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. */
@@ -368,6 +383,7 @@ function readFolder(dir: string, name: string, org: string | undefined, seen: st
     ...(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.extract ? { extract: envelope.extract as ObjectDefinition["extract"] } : {}),
     ...(dataset ? { dataset } : {}),
     props,
     ownProps,

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

@@ -68,11 +68,18 @@ export interface MakeEntry {
   /** How many of this object one source makes (owner, 2026-09-13): one, or many. The read asks by it; a part's entry says none. */
   cardinality?: "one" | "many";
   /**
-   * WRITTEN FROM EVERY SECTION (owner, 2026-10-05): `per: section` writes this object after the
-   * document is cut, one read per stored piece of each named section, instead of in the
-   * document's first read, which sees only its first two pages and its headings.
+   * WRITTEN FROM EVERY PAGE (owner, 2026-10-05; page-store.md, 2026-10-07: no sections): `per: page`
+   * writes this object once the document's pages are kept, one read per page, instead of in the
+   * document's first read, which sees only its first two pages.
    */
-  per?: "section";
+  per?: "page";
+  /**
+   * READ BY A NODE, FROM THE PAGES THAT NAME IT (pipelines README, "Or read by a node", owner
+   * 2026-10-09): with `per: page`, the node handed the best chunks with a template made from the
+   * 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" };
   sourceUrl?: string;
   sourceId?: string;
   /** The item's content, each value a reference over `item`, `index`, `config`, `collect`. */
@@ -154,7 +161,8 @@ function readFolder(dir: string, name: string, org: string | undefined): Pipelin
         ...(spec.any === true ? { any: list } : { each: list }),
         ...(spec.cardinality === "one" || spec.cardinality === "many" ? { cardinality: spec.cardinality as "one" | "many" } : {}),
         ...(whenOf(spec) ? { when: whenOf(spec) } : {}),
-        ...(spec.per === "section" ? { per: "section" as const } : {}),
+        ...(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" } : {}) } } : {}),
         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/definitions/registry/taskStarts.ts

@@ -0,0 +1,76 @@
+/**
+ * A TASK START IS A TASK (docs/mcp/MCP_TASKS.md § 2): a titled, described Task Start has an MCP
+ * tool on our own door, so any Agent a line is drawn to on its canvas can call it, and is
+ * answered with an MCP task. One rule, read by the engine's Task Start (what it offers a wired
+ * Agent) and the server (the tool it registers), so the two always name the same tool.
+ */
+import { AGENT_CARD, listAgents, type AgentFile } from "./agents.js";
+import { listApps } from "./catalog.js";
+
+/** A Task Start as a workflow saves it. */
+export interface TaskStartNode {
+  id: string;
+  type?: string;
+  data?: { config?: Record<string, unknown> };
+}
+
+const kebab = (s: string) =>
+  s
+    .trim()
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+
+const text = (v: unknown) => (typeof v === "string" ? v.trim() : "");
+
+/**
+ * A TASK START'S NAME (docs/mcp/MCP_TASKS.md § 2a, step U2): its own `name` field, set once, so its
+ * URI (`unoverse://tasks/<org>/<name>`) never moves when someone renames the title. A Task Start
+ * saved before the field existed is named from its title, as it always was, and that name is
+ * written into the field on its next save (`withFixedTaskName`), so from then on it stays put.
+ */
+export function taskStartName(node: TaskStartNode): string {
+  const cfg = node.data?.config ?? {};
+  return text(cfg.name) || kebab(text(cfg.title));
+}
+
+/** The node with its name written in, when it has a title and no name yet. Saving calls this. */
+export function withFixedTaskName<T extends TaskStartNode>(node: T): T {
+  if (node.type !== "InputTrigger") return node;
+  const cfg = node.data?.config ?? {};
+  if (text(cfg.name) || !text(cfg.title)) return node;
+  return { ...node, data: { ...node.data, config: { ...cfg, name: kebab(text(cfg.title)) } } };
+}
+
+/**
+ * The Task a Task Start is, or undefined when it is not one yet (no title, or nothing saying what
+ * it does, or its workflow belongs to no org's app). An Agent file that already names this start
+ * IS its Task, so the start reuses that file's tool rather than minting a second one.
+ */
+export function taskOfStart(workflowId: string, node: TaskStartNode): AgentFile | undefined {
+  if (node.type !== undefined && node.type !== "InputTrigger") return undefined;
+  const known = listAgents().find((a) => a.workflow === workflowId && a.trigger === node.id);
+  if (known) return known;
+  const cfg = node.data?.config ?? {};
+  const title = text(cfg.title);
+  const description = text(cfg.description);
+  const whenToUse = text(cfg.whenToUse);
+  const id = taskStartName(node);
+  if (!id || (!description && !whenToUse)) return undefined;
+  const org = listApps().find((a) => a.binding?.workflow === workflowId)?.org;
+  if (!org) return undefined;
+  return {
+    name: `${org}/${id}`,
+    org,
+    id,
+    title,
+    ...(description ? { description } : {}),
+    ...(whenToUse ? { whenToUse } : {}),
+    app: AGENT_CARD,
+    workflow: workflowId,
+    trigger: node.id,
+    ...(text(cfg.resultFrom) ? { output: text(cfg.resultFrom) } : {}),
+    path: "",
+  };
+}

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/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 });
   }
 }
 
@@ -1039,7 +1042,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/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

@@ -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.mjs

@@ -29,7 +29,7 @@ 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"]);
+export const PROP_KEYS = new Set(["type", "input", "description", "from", "hydrate", "enum", "oneOf", "minLength", "maxLength", "minItems", "maxItems", "items", "reuse", "answeredBy"]);
 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). */
@@ -117,7 +117,7 @@ export function envelopeFindings(name, envelope, file = `${name}.yaml`) {
       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`);
+      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 +158,15 @@ 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`);
+  }
+  // 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 +313,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"]);
 const FIELD = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 /**
@@ -381,8 +390,10 @@ 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 and read (${see})`);
+        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`);

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

@@ -60,6 +60,8 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
     userId: pub?.userId,
     chatId: pub?.chatId,
     accessToken: executionContext?.auth?.accessToken,
+    // The run's stop signal: a task this Agent follows is cancelled when its run stops.
+    signal: executionContext?.abortSignal as AbortSignal | undefined,
   };
   /**
    * THE CALLER, for a tool the MODEL calls: each records its own call on the trace under this
@@ -79,7 +81,11 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
    * would silently drop elicitation — the app would render and the model would never
    * learn what the human said.
    */
-  const appInvokers = new Map<string, (input: unknown) => Promise<unknown>>();
+  const appInvokers = new Map<string, (input: unknown, hooks?: { onStatus?: (statusMessage: string) => void }) => Promise<unknown>>();
+  // A WIRED TASK (a Task Start a line is drawn from, docs/mcp/MCP_TASKS.md § 2) names its MCP
+  // tool: it is called through the front door and followed as an MCP task, like a found one.
+  for (const [name, m] of Object.entries<any>(schema.methods))
+    if (typeof m?.taskTool === "string" && m.taskTool) appInvokers.set(name, harness.workflowTaskInvoker({ taskTool: m.taskTool }, called));
 
   /**
    * Which apps this run has already unlocked, by component name.
@@ -191,9 +197,10 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
       return tools;
     },
 
-    async call(name, args) {
+    async call(name, args, hooks) {
       const app = appInvokers.get(name);
-      if (app) return stringify(await app(args));
+      // A followed task's status, as it changes, goes to whoever asked (the tool loop narrates it).
+      if (app) return stringify(await app(args, hooks));
       // THE ARGUMENTS GO OUT AS THE MODEL WROTE THEM. A wire-level rewrite used to strip
       // queries the conversation had already searched; it was removed 2026-08-16 because it
       // silently competed with the tool descriptions for the same decision, and the

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

@@ -0,0 +1,20 @@
+/**
+ * A MARKETPLACE MCP IS A TASK (docs/mcp/MCP_TASKS.md § 2a): `unoverse://tasks/marketplace/<node>`,
+ * the node's type in kebab case, names a marketplace node that offers MCP tools, and listing it
+ * hands over every tool that MCP offers. This is the one place that reads it, for the Agent's
+ * runner and for every screen that draws an Agent.
+ */
+import { getLoadedManifestTypes, getManifestNode } from "./index.js";
+import { taskParts, MARKETPLACE_ORG } from "../definitions/registry/taskUri.js";
+
+/** A node type's task name: `SignalSave` → `signal-save`. */
+export const mcpTaskName = (type: string): string => type.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+
+/** The marketplace MCP a task names: the node type that offers MCP tools, or null. */
+export function marketplaceMcp(uri: string, types: string[] = getLoadedManifestTypes()): string | null {
+  const p = taskParts(uri);
+  if (!p || p.org !== MARKETPLACE_ORG) return null;
+  return (
+    types.find((t) => mcpTaskName(t) === p.name && ((getManifestNode(t)?.definition?.serviceConnectors ?? []) as Array<{ serviceType?: string }>).some((c) => c?.serviceType === "mcp")) ?? null
+  );
+}

package/vendor/base/src/manifests/runtime/http/request.ts

@@ -512,8 +512,11 @@ export async function runCalls(
   ctx: RunContext,
   label: string,
   store?: StateStore,
+  /** Replies already in hand from earlier calls the CALLER made itself (a lifecycle hook's node
+   *  calls, server mcp/lifecycleYaml.ts), so these calls see them as `calls.<name>` too. */
+  earlier?: Record<string, any>,
 ): Promise<{ results: Record<string, any>; last: any }> {
-  const results: Record<string, any> = {};
+  const results: Record<string, any> = { ...(earlier ?? {}) };
   let last: any = undefined;
 
   for (const call of calls) {