@unoverse-platform/studio 0.1.116 → 0.1.117

package/local/scaffold.d.mts

@@ -13,6 +13,7 @@ export function createProject(home: string, name: string): string;
 export function createFirstProject(home: string, name: string): string;
 
 /** Make `dir` one org's own repo (UNO-88): folders at the root, unoverse.yaml declaring the org, samples, editor globs, the check, Git. */
+export const ORG_FOLDERS: string[];
 export function createOrgRepo(dir: string, org: string): { state: "committed" | "no-identity" | "inside-repo" | "no-git"; message?: string };
 
 /** Make `home` a Git repo on main with a first commit, unless it already is one; never an author it was not given. */

package/local/scaffold.mjs

@@ -77,6 +77,9 @@ export function createProject(home, name) {
   return fillOrgFolder(root);
 }
 
+/** The folder of every authored kind, at an org repo's root (packages/docs/onboarding/studio.md). */
+export const ORG_FOLDERS = ["components", "apps", "templates", "atoms", "skills", "blocks", "nodes", "agents", "objects", "pipelines"];
+
 /**
  * One org's folder, filled: the welcome component, the sample styles, identity, app and
  * chat component. Shared by the monorepo shape (design/<org>/) and an org repo, whose root
@@ -93,6 +96,15 @@ function fillOrgFolder(root, { baselineOnly = false } = {}) {
   const dirs = baselineOnly ? ["styles", "identity"] : ["components/welcome", "apps", "styles", "skills", "blocks", "identity"];
   for (const d of dirs) mkdirSync(join(root, d), { recursive: true });
   if (!baselineOnly) writeFileSync(join(root, "components/welcome/welcome.yaml"), WELCOME);
+  // EVERY KIND'S FOLDER, EMPTY (owner, 2026-10-25). The baseline ruling dropped the SAMPLES; the
+  // folders went with them only because they were made beside the samples. A new org shows
+  // where each kind lives from the first minute. `.gitkeep` because Git keeps no empty folder.
+  if (baselineOnly) {
+    for (const d of ORG_FOLDERS) {
+      mkdirSync(join(root, d), { recursive: true });
+      if (readdirSync(join(root, d)).length === 0) writeFileSync(join(root, d, ".gitkeep"), "");
+    }
+  }
 
   // Worked example styles (sample-styles: brand ingredients + the override rules), so
   // styles/ is never an empty folder with no hint of the token cascade. Per PROJECT,

package/package.json

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

package/screens/AgentChain.tsx

@@ -21,11 +21,11 @@ export interface AgentFolderItem {
   /** Its picture, an image URL. */
   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[];
-  triggers: { name: string; node?: string; wakes?: string }[];
+  triggers: { name: string; node?: string; wakes?: string; config?: Record<string, unknown> }[];
   checkIn?: string;
   memory?: { agent?: string };
   askWhenUnsure?: string;
@@ -58,7 +58,12 @@ function taskLabel(uri: string, org: string): { name: string; from?: string } {
   return m[1] === org ? { name: m[2] } : { name: m[2], from: m[1] };
 }
 
-export function AgentChain({ agent: given }: { agent: AgentFolderItem }) {
+/**
+ * `mailbox`: its connected address in this environment (never in the file), drawn on the triggers
+ * its mailbox serves; `says`, by trigger, whether each works here today; `onConnect`, when the
+ * viewer may connect one, puts Connect there.
+ */
+export function AgentChain({ agent: given, mailbox, says, onConnect, connecting }: { agent: AgentFolderItem; mailbox?: string | null; says?: Record<string, string>; onConnect?: () => void; connecting?: boolean }) {
   // Every list may be absent (a hand-written file, an older server): drawn as empty, never a crash.
   const agent: AgentFolderItem = {
     ...given,
@@ -108,13 +113,19 @@ export function AgentChain({ agent: given }: { agent: AgentFolderItem }) {
           {ways.length === 0 && <div className="text-[12px] text-gray-500">None yet</div>}
           {ways.map((w) => {
             const Icon = WAY_ICONS[w.name] ?? Radio;
+            const mail = w.node === "MailboxMCP";
             return (
               <div key={w.name} className={TILE}>
                 <span className={GLYPH}><Icon size={15} strokeWidth={1.8} /></span>
-                <div className="min-w-0">
+                <div className="min-w-0 flex-1">
                   <div className="truncate text-[13px] font-medium capitalize text-gray-900">{w.name}</div>
-                  <div className="truncate text-[11px] text-gray-500">{w.name === "spatial" ? "found in Spatial" : [w.node, w.wakes ? WAKES[w.wakes] ?? w.wakes : null].filter(Boolean).join(", ")}</div>
+                  <div className="truncate text-[11px] text-gray-500">{mail && mailbox !== undefined ? mailbox ?? "No mailbox connected" : says?.[w.name] ?? (w.name === "spatial" ? "found in Spatial" : [w.node, w.wakes ? WAKES[w.wakes] ?? w.wakes : null].filter(Boolean).join(", "))}</div>
                 </div>
+                {mail && onConnect && (
+                  <button type="button" disabled={connecting} onClick={onConnect} className="shrink-0 rounded-md border border-gray-300 bg-white px-2 py-1 text-[11px] font-medium text-gray-800 hover:bg-gray-50 disabled:opacity-50">
+                    {connecting ? "Connecting" : mailbox ? "Change" : "Connect"}
+                  </button>
+                )}
               </div>
             );
           })}
@@ -130,17 +141,21 @@ export function AgentChain({ agent: given }: { agent: AgentFolderItem }) {
               {agent.role && <div className="text-[12px] text-gray-600">{agent.role}</div>}
             </div>
           </div>
-          <dl className="grid grid-cols-[auto_1fr] gap-x-3 gap-y-1 text-[12px]">
-            <dt className="text-gray-500">Model</dt>
-            <dd className="truncate font-mono text-gray-800">{agent.model?.use ?? "not set"}</dd>
-            <dt className="text-gray-500">Budget</dt>
-            <dd className="text-gray-800">
+          <div className="grid grid-cols-[auto_1fr] gap-x-3 gap-y-1 text-[12px]">
+            <div className="text-gray-500">Model</div>
+            <div className="truncate font-mono text-gray-800">{agent.model?.use ?? "not set"}</div>
+            <div className="text-gray-500">Reasoning</div>
+            <div className="text-gray-800">{agent.model?.reasoning ?? "the model's default"}</div>
+            <div className="text-gray-500">Turns</div>
+            <div className="text-gray-800">{agent.model?.turns ? `${agent.model.turns} a run` : "the model's default"}</div>
+            <div className="text-gray-500">Budget</div>
+            <div className="text-gray-800">
               {agent.budget?.perDay ? `${agent.budget.perDay} a day` : "not set"}
               {agent.budget?.perRun ? `, ${agent.budget.perRun} a run` : ""}
-            </dd>
-            <dt className="text-gray-500">Memory</dt>
-            <dd className="text-gray-800">{agent.memory?.agent === "on" ? "its own" : "off"}</dd>
-          </dl>
+            </div>
+            <div className="text-gray-500">Memory</div>
+            <div className="text-gray-800">{agent.memory?.agent === "on" ? "its own" : "off"}</div>
+          </div>
         </div>
 
         <ChevronRight size={18} className="mt-14 text-gray-300" />
@@ -200,17 +215,18 @@ export function AgentChain({ agent: given }: { agent: AgentFolderItem }) {
       </div>
 
       <div className={LABEL}>Settings</div>
-      <dl className="mb-5 grid grid-cols-[auto_1fr] gap-x-4 gap-y-1 rounded-lg border border-gray-200 bg-gray-50 p-4 text-[12px] text-gray-800">
-        {agent.model?.reasoning && (<><dt className="text-gray-500">Reasoning</dt><dd>{agent.model.reasoning}</dd></>)}
-        {agent.model?.fallback && (<><dt className="text-gray-500">Fallback model</dt><dd className="font-mono">{agent.model.fallback}</dd></>)}
-        <dt className="text-gray-500">Check-in</dt>
-        <dd>{agent.checkIn ? `every ${agent.checkIn}` : "only when reached"}</dd>
-        {agent.askWhenUnsure && (<><dt className="text-gray-500">Asks when unsure</dt><dd>in {agent.askWhenUnsure}</dd></>)}
-        <dt className="text-gray-500">Email</dt>
-        <dd>its connected mailbox, set in Signal</dd>
-        <dt className="text-gray-500">Folder</dt>
-        <dd className="font-mono">{agent.path}</dd>
-      </dl>
+      <div className="mb-5 grid grid-cols-[auto_1fr] gap-x-4 gap-y-1 rounded-lg border border-gray-200 bg-gray-50 p-4 text-[12px] text-gray-800">
+        {agent.model?.reasoning && (<><div className="text-gray-500">Reasoning</div><div>{agent.model.reasoning}</div></>)}
+        {agent.model?.turns && (<><div className="text-gray-500">Turns</div><div>{agent.model.turns} a run</div></>)}
+        {agent.model?.fallback && (<><div className="text-gray-500">Fallback model</div><div className="font-mono">{agent.model.fallback}</div></>)}
+        <div className="text-gray-500">Check-in</div>
+        <div>{agent.checkIn ? `every ${agent.checkIn}` : "only when reached"}</div>
+        {agent.askWhenUnsure && (<><div className="text-gray-500">Asks when unsure</div><div>in {agent.askWhenUnsure}</div></>)}
+        <div className="text-gray-500">Email</div>
+        <div>its connected mailbox, set in Signal</div>
+        <div className="text-gray-500">Folder</div>
+        <div className="font-mono">{agent.path}</div>
+      </div>
     </>
   );
 }

package/screens/AgentsView.tsx

@@ -39,6 +39,28 @@ interface AgentItem {
 }
 
 const ACCENT = "#7c3aed";
+
+/**
+ * COPY FOR CANVAS, AN AGENT WITH A VOICE (AGENTS.md § 5: its `voice` trigger names the node). The
+ * canvas's own clipboard payload, as Components writes it: only her face (the voice-chat component,
+ * her portrait and name). Clicking it starts her call; she works where she was woken, so her tasks
+ * show on that canvas.
+ */
+export function agentForCanvas(a: AgentFolderItem) {
+  if (!a.triggers.some((t) => t.name === "voice" && t.node)) return null;
+  const name = a.title ?? a.name;
+  // ONE NODE, ITS FACE. Its voice and its work are its own (engine agentKeys/talk.ts): `agent` is
+  // its address, and clicking the face starts its call on this canvas.
+  const face = {
+    id: `${a.name}-face1`,
+    type: "Component",
+    position: { x: 0, y: 0 },
+    data: { label: name, status: "ready", agent: `unoverse://agents/${a.org}/${a.name}`, config: { component: "voice-chat", portrait: a.avatar ?? "", orbSize: "360", assistantName: name, tagline: a.role ?? "" } },
+    style: { width: 520 },
+    draggable: true,
+  };
+  return { type: "gravity-workflow", version: 2, nodes: [face], edges: [] };
+}
 /** An Agent's mark: a bot's head, antenna up, two eyes. */
 const AGENT_ICON = `data:image/svg+xml;utf8,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="${ACCENT}" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="9" width="16" height="11" rx="3"/><path d="M12 9V5"/><circle cx="12" cy="4" r="1.2" fill="${ACCENT}"/><circle cx="9" cy="14.5" r="1.3" fill="${ACCENT}" stroke="none"/><circle cx="15" cy="14.5" r="1.3" fill="${ACCENT}" stroke="none"/><path d="M2 13v4M22 13v4"/></svg>`)}`;
 
@@ -49,6 +71,7 @@ export function AgentsView({ org = "all" }: { org?: string } = {}) {
   const available = useRegistryToggles("agent");
   const [selected, setSelected] = usePersistentState<string | null>("wb:agents:selected", null);
   const [error, setError] = useState<string | null>(null);
+  const [copied, setCopied] = useState(false);
 
   useEffect(() => {
     fetchUnoverse(`/dev/agents${org !== "all" ? `?org=${encodeURIComponent(org)}` : ""}`)
@@ -137,7 +160,24 @@ export function AgentsView({ org = "all" }: { org?: string } = {}) {
         {selected && folder ? (
           <div className={DOC}>
             <IdentityHeader
-              right={<ToggleSwitch on={available.isEnabled(selected)} onClick={() => available.toggle(selected)} label="Available" />}
+              right={
+                <div className="flex items-center gap-3">
+                  {agentForCanvas(folder) && (
+                    <button
+                      onClick={async () => {
+                        await navigator.clipboard.writeText(JSON.stringify(agentForCanvas(folder), null, 2));
+                        setCopied(true);
+                        setTimeout(() => setCopied(false), 1600);
+                      }}
+                      className="rounded border border-gray-300 px-2 py-0.5 text-[11px] font-medium text-gray-600 transition hover:bg-gray-50"
+                      title="Copy this Agent, with its voice, for a canvas: paste (Cmd+V) on any workflow canvas"
+                    >
+                      {copied ? "✓ Copied, paste on canvas" : "⧉ Copy for Canvas"}
+                    </button>
+                  )}
+                  <ToggleSwitch on={available.isEnabled(selected)} onClick={() => available.toggle(selected)} label="Available" />
+                </div>
+              }
               logoUrl={folder.avatar ?? AGENT_ICON}
               accent={ACCENT}
               name={folder.title ? `${folder.title}${folder.role ? `, ${folder.role}` : ""}` : selected}

package/screens/TemplatesLibraryView.tsx

@@ -14,7 +14,7 @@
  *
  * NOT TemplatesView.tsx: that name is taken by the Apps screen (the legacy noun).
  */
-import { useEffect, useMemo, useState, useSyncExternalStore, useCallback, type MouseEvent as ReactMouseEvent } from "react";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore, useCallback, type MouseEvent as ReactMouseEvent } from "react";
 import { ComponentStore, type ResolvedTheme } from "@unoverse/sdk";
 import { UnoverseComponent } from "./react/unoverse";
 import { client, authedFetch, usePersistentState, useRegistryToggles, ToggleSwitch } from "studio-host";
@@ -56,6 +56,9 @@ interface TemplateDef {
   preview?: Record<string, string[]>;
   /** The components it holds, one stand-in per item of its own preview data, per state. */
   heldSeeds?: Record<string, { key: string; component: string; props: Record<string, unknown> }[]>;
+  /** The template's own props (the lists it holds, a picture a hook fills): their previews seed
+   *  the instance, so a layout-level Each has items to walk and a held card a spot to draw in. */
+  props?: Record<string, { preview?: unknown; default?: unknown } | null>;
 }
 
 const PREVIEW_CHAT = "preview";
@@ -184,7 +187,14 @@ export function TemplatesLibraryView({ theme, org }: { theme: ResolvedTheme; org
       type: "COMPONENT_INIT",
       chatId: PREVIEW_CHAT,
       nodeId: TEMPLATE_NODE,
-      component: { type: ref, componentUrl: `unoverse://templates/${ref}`, props: {} },
+      // ITS OWN PROPS, seeded as a part's are (`preview ?? default`): a template whose layout walks
+      // a list it holds drew nothing here, because the instance arrived empty while the held
+      // stand-ins beneath it waited for an Each that never ran (observed 2026-10-23).
+      component: {
+        type: ref,
+        componentUrl: `unoverse://templates/${ref}`,
+        props: Object.fromEntries(Object.entries(current.props ?? {}).map(([k, v]) => [k, v?.preview ?? v?.default]).filter(([, v]) => v !== undefined)),
+      },
     });
     const base = current.defaultLayout ?? (current.layouts ? Object.keys(current.layouts)[0] : undefined);
     if (base) store.mergeComponentState(PREVIEW_CHAT, TEMPLATE_NODE, { state: base });
@@ -246,6 +256,25 @@ export function TemplatesLibraryView({ theme, org }: { theme: ResolvedTheme; org
     if ((own?.state ?? own?.view ?? own?.defaultState) !== activeState) store.mergeComponentState(PREVIEW_CHAT, TEMPLATE_NODE, { state: activeState });
   }, [store, holdsItems, activeState]);
 
+  // A VIEW OPENING RUNS THE HOOK SCOPED TO IT (docs/design/lifecycle-hooks.md), as the app's stream
+  // would: the template's own fields so far as `props`, the state as the layout entered, and what
+  // comes back merged into the instance. Once per view per template; a host with no universe
+  // to run it (local Studio) fails quietly and the preview keeps its stand-ins.
+  const ranHooks = useRef(new Set<string>());
+  useEffect(() => {
+    if (!uri || !activeState || !client.runTask) return;
+    const key = `${uri}#${activeState}`;
+    if (ranHooks.current.has(key)) return;
+    ranHooks.current.add(key);
+    const own = (store.get(PREVIEW_CHAT, TEMPLATE_NODE) ?? {}) as Record<string, unknown>;
+    client
+      .runTask(uri, "onEnterView", own, activeState)
+      .then((fields) => {
+        if (fields && Object.keys(fields).length) store.mergeComponentState(PREVIEW_CHAT, TEMPLATE_NODE, fields);
+      })
+      .catch((e: unknown) => console.warn(`[studio] ${uri} onEnterView(${activeState}) did not run:`, e));
+  }, [store, uri, activeState]);
+
   // GROUPED BY CATEGORY, exactly as Components groups its rail — the shelf is no longer a
   // flat list the moment small templates land on it (the `Blocks` shelf: pair, feature,
   // single, rail, stack, statement) and a page has to be found among them. The category is
@@ -480,7 +509,7 @@ export function TemplatesLibraryView({ theme, org }: { theme: ResolvedTheme; org
             );
           })()}
 
-          <div className="flex-1 overflow-auto p-10">
+          <div data-print-stage className="flex-1 overflow-auto p-10">
             <div className="mx-auto max-w-full transition-[width] duration-200" style={{ width: stageWidth ?? "100%" }}>
               {uri && <UnoverseComponent key={uri} client={client} store={store} chatId={PREVIEW_CHAT} nodeId={TEMPLATE_NODE} theme={theme} />}
             </div>

package/screens/TemplatesView.tsx

@@ -32,7 +32,7 @@ import { NAV, NAV_SECTION, SCREEN, navItem, navSubItem } from "./chrome";
 
 // Per-APP test conversation: each app chats in its own conversation id, so testing
 // one client's app never inherits another's agent history/memory (the "BPP answers
-// about SAB" trap — same workflow, polluted shared context).
+// about a bank" trap — same workflow, polluted shared context).
 // …and a fresh conversation per PAGE LOAD: the nonce is minted once per module load,
 // so refreshing the page naturally starts a NEW conversation (fresh agent thread,
 // fresh durable surfaces) — history never outlives the screen it happened on.
@@ -373,7 +373,7 @@ export function TemplatesView({
     const base = store.getTimeline().length === 0 ? "isEmpty" : "hasMessages";
     return states.find((s) => s.when === base)?.name ?? null;
   }, [storeVersion, store, selectedDef]);
-  // The preview renders under the SELECTED APP'S ORG theme — a SAB app is SAB-red, a
+  // The preview renders under the SELECTED APP'S ORG theme — a a bank app is a bank-red, a
   // BPP app cobalt, whatever the header org scope shows. The header toggle picks the
   // light/dark variant; the app's org picks whose brand. Falls back to the app-level
   // theme until the fetch resolves (or for org-less templates).

package/screens/index.ts

@@ -25,7 +25,7 @@ export { TemplatesLibraryView } from "./TemplatesLibraryView";
 export { DesignSystemView } from "./DesignSystemView";
 export { SkillsView } from "./SkillsView";
 // Agents: the one file authored for the map (docs.unoverse.ai/design/tasks), one lane in both Studios.
-export { AgentsView } from "./AgentsView";
+export { AgentsView, agentForCanvas } from "./AgentsView";
 // An Agent drawn off its agent.yaml: Studio's lane, and Signal's Agent page beside its runs.
 export { AgentChain } from "./AgentChain";
 export type { AgentFolderItem } from "./AgentChain";

package/src/host.ts

@@ -110,6 +110,11 @@ class LocalUnoverseClient {
     );
   }
 
+  /** A component's task runs in a universe. A folder runs none, so it fills nothing. */
+  async runTask(): Promise<Record<string, unknown>> {
+    return {};
+  }
+
   /**
    * Read a definition, and STAMP EVERY NODE WITH ITS PATH.
    *

package/src/index.css

@@ -5,3 +5,14 @@ body,
 #root {
   height: 100%;
 }
+
+/* PRINT: only the template stage prints, one 1280x720 page per slide; Studio's chrome stays out.
+   The page is the stage's own size, so a stage drawn at Desktop width (1280) prints at scale 1. */
+@media print {
+  @page { size: 1280px 720px; margin: 0; }
+  html, body, #root, #root * { height: auto !important; min-height: 0 !important; overflow: visible !important; }
+  body *:not([data-print-stage]):not([data-print-stage] *):not(:has([data-print-stage])) { display: none !important; }
+  :has(> [data-print-stage]), :has([data-print-stage]) { display: block !important; padding: 0 !important; margin: 0 !important; border: 0 !important; }
+  [data-print-stage] { padding: 0 !important; }
+  [data-print-stage] > div { width: 1280px !important; max-width: none !important; margin: 0 !important; }
+}

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

@@ -72,7 +72,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
         // A TASK IS A TOOL, DESCRIBED LIKE ONE (owner ruling 2026-09-08). This used to close
         // with TASK_ETIQUETTE — "calling this runs an Agent and holds until it completes while
         // the person watches its progress on screen; say in one short sentence what you are
-        // doing" — and the only thing it told the model to DO was speak. Measured on SAB
+        // doing" — and the only thing it told the model to DO was speak. Measured on a bank
         // (2026-09-08): across four runs of one question the model called once and, three
         // times, emitted exactly one sentence of intent and ended the turn, with no
         // function-call events in the stream at all.

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

@@ -22,6 +22,7 @@
  *   lean        projecting a result down to what the model needs
  *   tools       minting a model tool from a discovered app
  *   invoke      THE ONE WIRE CALL, where our code ends and native MCP begins
+ *   progressive many tools held behind search_tools and call_tool (MCP Client Best Practices)
  *   memory*     conversation ingest and user-memory hydration
  */
 
@@ -38,7 +39,8 @@ export { parseToolResult, isTurnEndingHandoff } from "./handoff.js";
 export { rowComponentsFromResults, renderRowComponents, rankedRowIds, componentTypeFromAppUri, onScreenRead, onScreenPlaces, placesOn, placesLine, rememberRows, rowsById, cardIdOf, screenOf, openedOn, type ScreenItem, openTasksOn, onScreenLine, ABOUT_THE_PAGE, ABOUT_THE_OPENED } from "./rowComponents.js";
 export { leanToolResultForModel } from "./lean.js";
 export { toolDefFromDiscoveredMCP, resolveToolDefNative, isBindinglessComponentApp, componentAppInvoker, isWorkflowTask, workflowTaskInvoker, workflowAppInvoker, modelToolName, objectFunctionToolDef, objectFunctionInvoker } from "./tools.js";
-export { invokeTaskNative, connectPlatformMcp, TRACE_META } from "./invoke.js";
+export { invokeTaskNative, connectPlatformMcp, TRACE_META, readTask, answerTask } from "./invoke.js";
+export { shouldDefer, metaTools, searchAnswer, searchTools, estimateTokens, DEFER_ABOVE_TOKENS, SEARCH_TOOLS, CALL_TOOL, type HeldTool } from "./progressive.js";
 
 export { ingestConversationTurn, type ConversationTurn } from "./memoryIngest.js";
 export { fetchUserMemoryContext, hydratePromptWithUserMemory } from "./memoryContext.js";

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

@@ -84,20 +84,11 @@ type CallResult = {
   structuredContent?: Record<string, any>;
 };
 
-/**
- * ONE CALL, FOLLOWED AS AN MCP TASK WHEN IT IS ONE (docs/mcp/MCP_TASKS.md steps 6 and 7). Every
- * Task is an MCP task: a workflow, a form, an app that asks. The harness calls as a 2026-07-28
- * client that declared the tasks extension, so a Task answers at once with its task and the
- * official client (`@modelcontextprotocol/ext-tasks/client`) follows it to its result; a call
- * with nothing to wait for answers at once, through the same client. Several calls in one turn
- * each follow their own task, side by side.
- *
- * The one piece of host code the library asks for is `rawDispatch`: it sends one JSON-RPC request
- * on the 2026 framing and hands back the response. The host owns request ids, so it adds them.
- */
-async function callFollowingTasks(toolId: string, args: Record<string, unknown>, ctx: AppInvocationContext): Promise<CallResult> {
+/** A 2026-07-28 client on the platform's /mcp that declared the tasks extension, and the official
+ *  task session over it: what every native task call below is made on. Close the client after. */
+async function openTaskSession(ctx: Pick<AppInvocationContext, "baseUrl" | "accessToken">) {
   const { Client, StreamableHTTPClientTransport } = await import("@modelcontextprotocol/client");
-  const { createTaskSessionFromClient, resultFromTaskOutcome } = await import("@modelcontextprotocol/ext-tasks/client");
+  const { createTaskSessionFromClient } = await import("@modelcontextprotocol/ext-tasks/client");
   const base = (ctx.baseUrl || process.env.UNOVERSE_SERVICE_URL || "http://localhost:4106").replace(/\/$/, "");
   const auth: Record<string, string> = ctx.accessToken ? { Authorization: `Bearer ${ctx.accessToken}` } : {};
   const clientInfo = { name: "unoverse-agent-mcp", version: "1.0.0" };
@@ -130,12 +121,29 @@ async function callFollowingTasks(toolId: string, args: Record<string, unknown>,
     const answers = text.split("\n").filter((l) => l.startsWith("data: ")).map((l) => JSON.parse(l.slice(6)));
     return answers.filter((m) => m.id === id).pop() ?? answers.pop();
   };
+  const session = createTaskSessionFromClient(client as never, {
+    endpointId: `${base}/mcp`,
+    rawDispatch: rawDispatch as never,
+    v2RequestFraming: { protocolVersion: MODERN, clientInfo, clientCapabilities },
+  } as never);
+  return { client, session };
+}
+
+/**
+ * ONE CALL, FOLLOWED AS AN MCP TASK WHEN IT IS ONE (docs/mcp/MCP_TASKS.md steps 6 and 7). Every
+ * Task is an MCP task: a workflow, a form, an app that asks. The harness calls as a 2026-07-28
+ * client that declared the tasks extension, so a Task answers at once with its task and the
+ * official client (`@modelcontextprotocol/ext-tasks/client`) follows it to its result; a call
+ * with nothing to wait for answers at once, through the same client. Several calls in one turn
+ * each follow their own task, side by side.
+ *
+ * The one piece of host code the library asks for is `rawDispatch`: it sends one JSON-RPC request
+ * on the 2026 framing and hands back the response. The host owns request ids, so it adds them.
+ */
+async function callFollowingTasks(toolId: string, args: Record<string, unknown>, ctx: AppInvocationContext): Promise<CallResult> {
+  const { resultFromTaskOutcome } = await import("@modelcontextprotocol/ext-tasks/client");
+  const { client, session } = await openTaskSession(ctx);
   try {
-    const session = createTaskSessionFromClient(client as never, {
-      endpointId: `${base}/mcp`,
-      rawDispatch: rawDispatch as never,
-      v2RequestFraming: { protocolVersion: MODERN, clientInfo, clientCapabilities },
-    } as never);
     const execution = await session.callTool(
       // THE TOOL NAME FROM THE TASK'S ONE URI (docs/mcp/MCP_TASKS.md § 2a): a task URI or its short
       // form `<org>/<name>` is called as `<org>.<name>`; anything else (a bare app id) as given.
@@ -257,6 +265,9 @@ export async function invokeTaskNative(
       return {
         status: "completed",
         output: { result: result.structuredContent.result },
+        // THE TASK'S OWN ID (owner 2026-10-24: "save the task, show it in the timeline, click it
+        // to see it"): the run that did this, so the caller can record it where the work belongs.
+        ...(result.structuredContent?.executionId ? { run: result.structuredContent.executionId } : {}),
         conversationId: result.structuredContent?.conversationId,
         message:
           "The Agent completed. `output.result` is what it found, already shown to the person on screen. " +
@@ -303,3 +314,36 @@ export async function invokeTaskNative(
 }
 
 // Memory ingest — every agent family saves completed turns the same way.
+
+/**
+ * A TASK THAT ALREADY EXISTS, by its id (docs/mcp/MCP_TASKS.md § 5c): the official client's
+ * `session.task(id)`. Read gives where it is and, once it has finished, what it produced; answer
+ * replies to what a waiting task asks (`tasks/update`). Nothing else: MCP offers nothing else.
+ */
+export async function readTask(taskId: string, ctx: Pick<AppInvocationContext, "baseUrl" | "accessToken">): Promise<{ taskId: string; status: string; statusMessage?: string; asks?: unknown; result?: string }> {
+  const { client, session } = await openTaskSession(ctx);
+  try {
+    const task = (session as any).task(taskId);
+    const view = await task.snapshot();
+    const raw = (view.raw ?? {}) as Record<string, any>;
+    const done = (raw.result?.content ?? []).find((c: any) => c?.type === "text")?.text;
+    return {
+      taskId: view.taskId,
+      status: view.status,
+      ...(view.statusMessage ? { statusMessage: view.statusMessage } : {}),
+      ...(raw.inputRequests && Object.keys(raw.inputRequests).length ? { asks: raw.inputRequests } : {}),
+      ...(typeof done === "string" && done ? { result: done } : {}),
+    };
+  } finally {
+    await client.close().catch(() => {});
+  }
+}
+
+export async function answerTask(taskId: string, inputResponses: Record<string, unknown>, ctx: Pick<AppInvocationContext, "baseUrl" | "accessToken">): Promise<void> {
+  const { client, session } = await openTaskSession(ctx);
+  try {
+    await (session as any).task(taskId).updateJson(inputResponses);
+  } finally {
+    await client.close().catch(() => {});
+  }
+}

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

@@ -0,0 +1,124 @@
+/**
+ * PROGRESSIVE TOOL DISCOVERY (MCP 2026-07-28, Client Best Practices; docs/mcp/MCP_2026-07-28.md
+ * § 4, 3e; packages/docs/nodes/mcp-services.md, "Many tools").
+ *
+ * A host with many tools does not hand the model every definition. It keeps them, gives the
+ * model a `search_tools` meta-tool, and loads a definition only when the job needs it. Our
+ * harness is the host for every Agent, so this is decided here, once, for every model.
+ *
+ * THE TOOL LIST NEVER CHANGES DURING A RUN. A found tool is not added to the list: it is called
+ * through `call_tool`, MCP's "single stable call_tool({name, args}) meta-tool so the array never
+ * changes". Adding it would break the model's prompt cache at that turn.
+ *
+ * Pure: the tools come in, the offer and the answers go out. The bridge does the calling.
+ */
+
+/** A tool as the bridge holds it: what the model would be offered, plus the server it is from. */
+export interface HeldTool {
+  name: string;
+  description: string;
+  parameters: unknown;
+  server?: string;
+}
+
+/**
+ * THE THRESHOLD, in estimated tokens of definitions. MCP: switch "once the tool definitions take
+ * up a significant part of the available context window", for example 1% to 5%. 2,000 is 1% of a
+ * 200k window and under 2% of a 128k one. Below it, every tool is offered as before.
+ */
+export const DEFER_ABOVE_TOKENS = 2000;
+
+/** How many tools one search hands back: a few that fit, never the catalogue. */
+const MATCHES = 5;
+
+export const SEARCH_TOOLS = "search_tools";
+export const CALL_TOOL = "call_tool";
+
+/** About four characters a token: the usual estimate, and close enough to pick a side of 2,000. */
+export function estimateTokens(tools: HeldTool[]): number {
+  return Math.ceil(JSON.stringify(tools.map(({ name, description, parameters }) => ({ name, description, parameters }))).length / 4);
+}
+
+/** Should these tools be held back behind search? */
+export function shouldDefer(tools: HeldTool[]): boolean {
+  return estimateTokens(tools) > DEFER_ABOVE_TOKENS;
+}
+
+/** A tool in one line: its name and the first sentence of what it does, never its schema. */
+function oneLine(t: HeldTool): string {
+  const first = String(t.description ?? "").split(/(?<=[.!?:])\s/)[0].trim();
+  return `- ${t.name}: ${first.length > 140 ? `${first.slice(0, 137)}...` : first}`;
+}
+
+/**
+ * THE CATALOGUE: every held tool in one line, grouped by server (MCP: "names and one-line
+ * descriptions", "group tools by server"). The model sees what it has and loads a definition only
+ * when it needs it; without the lines an Agent never knew a tool existed, so it never searched and
+ * named tools it did not have (Bob, 2026-10-11). Stable for the run, so the prompt cache holds.
+ */
+export function catalogue(held: HeldTool[]): string {
+  const groups = new Map<string, HeldTool[]>();
+  for (const t of held) {
+    const key = t.server ?? "";
+    groups.set(key, [...(groups.get(key) ?? []), t]);
+  }
+  return [...groups.entries()].map(([server, tools]) => [server ? `${server}:` : "", ...tools.map(oneLine)].filter(Boolean).join("\n")).join("\n");
+}
+
+/** The two meta-tools, offered in place of the held ones. The search carries the catalogue. */
+export function metaTools(held: HeldTool[]): HeldTool[] {
+  return [
+    {
+      name: SEARCH_TOOLS,
+      description:
+        `Load the full definition (input schema) of the tools you need before you call them. Describe the job in plain words, or give a tool's name; the answer is the tools that fit, each with its server and full input schema. Call it before ${CALL_TOOL} for any tool whose schema you do not yet hold. The tools you have:\n${catalogue(held)}`,
+      parameters: {
+        type: "object",
+        properties: { query: { type: "string", description: "What you need to do, e.g. 'save a person's email address'." } },
+        required: ["query"],
+      },
+    },
+    {
+      name: CALL_TOOL,
+      description: `Call one tool that ${SEARCH_TOOLS} found, by its exact name, with arguments matching its input schema.`,
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: `The tool's exact name, as ${SEARCH_TOOLS} gave it.` },
+          arguments: { type: "object", description: "The tool's arguments, matching its input schema." },
+        },
+        required: ["name"],
+      },
+    },
+  ];
+}
+
+const words = (s: string): string[] => s.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1);
+
+/**
+ * KEYWORD SEARCH, the first of MCP's strategies ("simple and effective, particularly for descriptive
+ * tool names and descriptions"). A word of the query in the tool's name counts most, then in its
+ * server, then in its description. A name's own parts count: `send_message` is "send" and "message".
+ */
+export function searchTools(held: HeldTool[], query: string): Array<{ name: string; server?: string; description: string; inputSchema: unknown }> {
+  const asked = [...new Set(words(query))];
+  const scored = held
+    .map((t) => {
+      const name = new Set(words(t.name.replace(/([a-z0-9])([A-Z])/g, "$1 $2")));
+      const server = new Set(words((t.server ?? "").replace(/([a-z0-9])([A-Z])/g, "$1 $2")));
+      const text = new Set(words(t.description));
+      const score = asked.reduce((s, w) => s + (name.has(w) ? 3 : 0) + (server.has(w) ? 2 : 0) + (text.has(w) ? 1 : 0), 0);
+      return { t, score };
+    })
+    .filter((x) => x.score > 0)
+    .sort((a, b) => b.score - a.score);
+  return scored.slice(0, MATCHES).map(({ t }) => ({ name: t.name, ...(t.server ? { server: t.server } : {}), description: t.description, inputSchema: t.parameters }));
+}
+
+/** The answer to a search the model reads: the matches, or what to do when there are none. */
+export function searchAnswer(held: HeldTool[], query: string): string {
+  const found = searchTools(held, String(query ?? ""));
+  if (found.length) return JSON.stringify({ tools: found });
+  const servers = [...new Set(held.map((t) => t.server).filter(Boolean))];
+  return JSON.stringify({ tools: [], note: `No tool matched "${query}". Describe the job in other words${servers.length ? `, or name a server: ${servers.join(", ")}` : ""}.` });
+}

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

@@ -192,7 +192,7 @@ export function componentAppInvoker(
  * `handoffTools` and nothing else, so `bridge.call` found no entry in `appInvokers` and fell
  * through to `api.callService`, which addresses SERVICE methods: the platform answered
  * "SpatialSearch has no service method \"sab-voice\"" and the call failed in 10ms while the
- * run still reported success. Observed live on SAB (2026-09-07): the app was found, minted
+ * run still reported success. Observed live on a bank (2026-09-07): the app was found, minted
  * and CALLED, and the person watched a blank panel. Every workflow-bound app shared this —
  * the path-B sibling three lines above had an invoker from the day it was written.
  */

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

@@ -112,7 +112,7 @@ export function inheritProps(
   // could send, which is exactly the venue-renaming this flag exists to prevent.
   // `input` TRAVELS TOO (2026-09-15). An atom that marks a field `input: false` (the button's
   // `icon` and `link`) says nobody outside fills it; without the word here the host inherited
-  // the field as fillable and the tool asked the model for it (SAB transfer: four fields it
+  // the field as fillable and the tool asked the model for it (a bank's transfer form: four fields it
   // could not honestly write). Same failure as `override` above, one word later.
   const CONTRACT = ["type", "description", "maxLength", "minItems", "maxItems", "items", "hydrate", "optional", "override", "preview", "input"] as const;
   // AN ATOM INSIDE AN `Each` DESCRIBES THE ITEM, not the page. The scope is the chain of