@unoverse-platform/studio 0.1.96 → 0.1.98

package/screens/TemplatesView.tsx

@@ -647,7 +647,11 @@ export function TemplatesView({
             ...restState,
             ...defaultsOf(c),
             ...(data ?? {}),
-            ...(view ? { view, defaultState: view } : { defaultState: "inline" }),
+            // ALL THREE SPELLINGS, as the activation below writes them: `state` is the ruled
+            // public-axis word (2026-08-29) and what a synthesized `Switch on: state` reads;
+            // with only the legacy two, the ladder placed a deal in the grid while the deal
+            // drew its FIRST face (observed 2026-09-11: list tiles inside a grid).
+            ...(view ? { state: view, view, defaultState: view } : { defaultState: "inline" }),
           },
         },
       });
@@ -815,19 +819,30 @@ export function TemplatesView({
       // a single-key object naming the component and carrying its own view + data
       // (UNOVERSE_INTERFACE_MODEL §3). Envelope instances arrive already in their view.
       const toSpec = (item: string | Record<string, Record<string, unknown>>): SeedSpec | null => {
+        // THE HASH NAMES THE STATE IT OPENS IN (STATE_MODEL rule 3; owner 2026-09-11: a
+        // preview is written `deal#grid`, the same address grammar as everywhere else).
+        // Split ONCE, for both forms: a mount state wraps each name as `{ "deal#grid": {} }`
+        // before it gets here, so the split lives beside the lookup, not on one branch.
+        const split = (ref: string): [string, string | undefined] => {
+          const [name, hash] = ref.split("#");
+          return [name, hash || undefined];
+        };
         if (typeof item === "string") {
-          const def = byName(item);
+          const [name, hash] = split(item);
+          const def = byName(name);
           // In the FLAT (container-model) list every entry is an envelope: a bare name
           // wakes in its own arrival face. Only the keyed legacy form seeds inline for
-          // the state chip to move.
-          return def ? { def, ...(flatPreview ? { envelope: true } : {}) } : null;
+          // the state chip to move. A hash seeds the instance's own view, as an envelope.
+          return def ? { def, ...(hash ? { envelope: true, view: hash } : flatPreview ? { envelope: true } : {}) } : null;
         }
-        const [name, body] = Object.entries(item ?? {})[0] ?? [];
-        if (!name) return null;
+        const [rawName, body] = Object.entries(item ?? {})[0] ?? [];
+        if (!rawName) return null;
+        const [name, hash] = split(rawName);
         const def = byName(name);
         if (!def) return null;
         const { view, ...data } = (body ?? {}) as Record<string, unknown>;
-        return { def, envelope: true, ...(typeof view === "string" && view ? { view } : {}), ...(Object.keys(data).length ? { data } : {}) };
+        const face = typeof view === "string" && view ? view : hash;
+        return { def, envelope: true, ...(face ? { view: face } : {}), ...(Object.keys(data).length ? { data } : {}) };
       };
       const set = entry
         ? entry.map(toSpec).filter((s): s is SeedSpec => Boolean(s))
@@ -1008,9 +1023,9 @@ export function TemplatesView({
               onClick={() => setMetaOpen((o) => !o)}
               className="flex items-center gap-1 rounded border px-2 py-0.5 font-medium"
               style={{ borderColor: theme.color["border.subtle"], color: metaOpen ? theme.color["text.primary"] : theme.color["text.secondary"], background: metaOpen ? theme.color["surface.sunken"] : "transparent" }}
-              title="Show the MCP app manifest"
+              title="Show the app's manifest: its meta, its binding, its shape"
             >
-              {selectedDef?.app ? "ⓘ MCP app" : "ⓘ Details"} <span className="opacity-60">{metaOpen ? "▴" : "▾"}</span>
+              ⓘ Manifest <span className="opacity-60">{metaOpen ? "▴" : "▾"}</span>
             </button>
           )}
 

package/screens/index.ts

@@ -1,7 +1,7 @@
 /**
  * studio: the Studio screens, owned once and imported by BOTH Studios,
  * the Canvas-embedded catalog and the standalone local authoring app.
- * See docs/architecture/LOCAL_STUDIO.md.
+ * See docs/architecture/authoring/LOCAL_STUDIO.md.
  *
  * These screens contain NO transport, auth or persistence of their own. Everything
  * host-specific is imported from the bare specifier `studio-host`, which each app
@@ -24,6 +24,9 @@ export { TemplatesView } from "./TemplatesView";
 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 { IdentityView } from "./IdentityView";
 export { PromptBlocksView } from "./PromptBlocksView";
 export { IdentityHeader } from "./IdentityHeader";
 export { stateActivation } from "./states";
@@ -32,5 +35,5 @@ export { stateActivation } from "./states";
 // so it is shared even though neither shares the screen around it.
 export { ConfigForm, defaultsFromSchema } from "./ConfigForm";
 // The source view renders only where the host grants source access, so it is exported
-// unconditionally and returns null in Canvas (docs/architecture/LOCAL_STUDIO.md).
+// unconditionally and returns null in Canvas (docs/architecture/authoring/LOCAL_STUDIO.md).
 export { SourceView } from "./SourceView";

package/src/App.tsx

@@ -5,7 +5,7 @@
  * Studio renders. This file only does what a host must: pick the project, pick the
  * theme variant, resolve the theme, and choose which screen is showing.
  *
- * See docs/architecture/LOCAL_STUDIO.md.
+ * See docs/architecture/authoring/LOCAL_STUDIO.md.
  */
 import { useEffect, useState } from "react";
 import type { ResolvedTheme } from "@unoverse/sdk";
@@ -15,7 +15,8 @@ import {
   TemplatesView,
   TemplatesLibraryView,
   DesignSystemView,
-  SkillsView,
+  SkillsView, AgentsView,
+  IdentityView,
   PromptBlocksView,
 } from "@unoverse/studio";
 import { client, usePersistentState } from "./host";
@@ -31,20 +32,25 @@ import {
   LayoutTemplate,
   Palette,
   Sparkles,
+  Bot,
   SquareDashed,
   TextQuote,
+  Landmark,
   type LucideIcon,
 } from "lucide-react";
 
-type View = "apps" | "templates" | "components" | "atoms" | "tokens" | "skills" | "prompts" | "nodes";
+type View = "apps" | "agents" | "templates" | "components" | "atoms" | "tokens" | "identity" | "skills" | "prompts" | "nodes";
 
 const NAV: { key: View; label: string; group: string; Icon: LucideIcon }[] = [
+  // Owner's order (2026-09-06): apps, agents, skills, templates, then the parts.
   { key: "apps", label: "Apps", group: "Build", Icon: LayoutDashboard },
+  { key: "agents", label: "Agents", group: "Build", Icon: Bot },
+  { key: "skills", label: "Skills", group: "Build", Icon: Sparkles },
   { key: "templates", label: "Templates", group: "Build", Icon: LayoutTemplate },
   { key: "components", label: "Components", group: "Build", Icon: SquareDashed },
   { key: "atoms", label: "Atoms", group: "Build", Icon: Atom },
   { key: "tokens", label: "Styles", group: "Build", Icon: Palette },
-  { key: "skills", label: "Skills", group: "AI", Icon: Sparkles },
+  { key: "identity", label: "Identity", group: "AI", Icon: Landmark },
   { key: "prompts", label: "Prompt Blocks", group: "AI", Icon: TextQuote },
   { key: "nodes", label: "Nodes", group: "Code", Icon: Boxes },
 ];
@@ -193,6 +199,8 @@ function Shell() {
           // Standalone Studio authors offline: open apps in MOCK (the defaultLive=true
           // resting mode is Canvas's, where the universe is right there).
           <TemplatesView theme={theme} themeName={variant} org={org} defaultLive={false} />
+        ) : view === "agents" ? (
+          <AgentsView org={org} />
         ) : view === "templates" ? (
           <TemplatesLibraryView theme={theme} org={org} />
         ) : view === "components" ? (
@@ -201,6 +209,8 @@ function Shell() {
           <AtomsView theme={theme} />
         ) : view === "tokens" ? (
           <DesignSystemView theme={theme} foundation={foundation} org={org} />
+        ) : view === "identity" ? (
+          <IdentityView org={org} />
         ) : view === "skills" ? (
           <SkillsView org={org} />
         ) : view === "nodes" ? (

package/src/NodeKeys.tsx

@@ -9,7 +9,7 @@
  * So this panel is read-only. It names the exact variable each field wants and says
  * whether it is set. Entering the value happens in the editor they are already in.
  *
- * See docs/architecture/LOCAL_STUDIO.md.
+ * See docs/architecture/authoring/LOCAL_STUDIO.md.
  */
 import { useEffect, useState } from "react";
 

package/src/host.ts

@@ -9,7 +9,7 @@
  * There is no auth here on purpose. Local Studio is offline and single-user: the files
  * are already yours. Authentication belongs to a universe, not to a folder.
  *
- * See docs/architecture/LOCAL_STUDIO.md.
+ * See docs/architecture/authoring/LOCAL_STUDIO.md.
  */
 import { useCallback, useEffect, useState } from "react";
 import type { ResolvedTheme, UnoverseDefinition, UnoverseClient } from "@unoverse/sdk";
@@ -44,7 +44,7 @@ export function liveUniverseUrl(): string | null {
  * The capability lives on the host for the reason `hasAuth` does: a shared screen must
  * never branch on which app it is running in. Canvas leaves it false, so hosted surfaces
  * render and never edit, by construction rather than by discipline
- * (docs/architecture/LOCAL_STUDIO.md §The capability gate).
+ * (docs/architecture/authoring/LOCAL_STUDIO.md §The capability gate).
  */
 export const hasSourceAccess = true;
 
@@ -129,19 +129,6 @@ class LocalUnoverseClient {
     return def;
   }
 
-  /**
-   * The SYNCHRONOUS cached-definition peek (see the SDK client). Studio's `readDefinition`
-   * fetches every time and keeps no cache — deliberately, so an edit on disk shows up on
-   * the next read — so there is nothing to peek and the honest answer is `null`.
-   *
-   * `null` means "no opinion", never "no": the one caller (the latch derivation on send)
-   * treats it as "no latch", which is right here. Studio previews a definition; it has no
-   * live conversation to address a component from. Present so the structural contract holds
-   * — the SDK takes this client by shape, so a missing method is a crash, not a type error.
-   */
-  peekDefinition(_uri: string): UnoverseDefinition | null {
-    return null;
-  }
 
   async readTheme(name = "light"): Promise<ResolvedTheme> {
     const r = await fetch(`/local/theme?ref=${encodeURIComponent(name)}`);
@@ -187,7 +174,7 @@ export function usePersistentState<T>(key: string, initial: T): [T, React.Dispat
   return [value, setValue];
 }
 
-export type RegistryKind = "node" | "skill" | "app" | "prompt" | "component" | "template";
+export type RegistryKind = "node" | "skill" | "app" | "prompt" | "component" | "template" | "identity" | "agent";
 
 /**
  * Registry toggles decide what a RUNNING universe exposes; they persist to

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

@@ -5,7 +5,7 @@
  * kinds into one shape, so a model gets one tool per row regardless of which kind it was.
  * Also the etiquette an interactive app carries, and the anchoring a follow-up search needs.
  */
-import type { AgentToolExchange, DiscoveredMCP, AppInvocationContext } from "./types.js";
+import type { AgentToolExchange, DiscoveredMCP, AppInvocationContext, OfferedFunction } from "./types.js";
 
 /** The discovery tools whose results can carry `object_type: "mcp"` rows. */
 export const DISCOVERY_TOOL_NAMES: readonly string[] = ["findIntent", "discoverRelated"];
@@ -25,7 +25,7 @@ import { leanToolResultForModel } from "./lean.js";
  *     calling it fires `workflow@trigger`.
  *   - Path B — bindingless component-app rows (§0.1): an `app` URI but NO workflow. The
  *     app IS the tool; calling it makes the held native `/mcp` call
- *     (`invokeComponentAppNative`) — the SERVER renders the component + elicits, nothing
+ *     (`invokeTaskNative`) — the SERVER renders the component + elicits, nothing
  *     to fire. Carries `component` (the app-tool id) instead of workflow/trigger.
  *
  * Path B also covers CONTENT-TREE rows (object_type "service"/"need") with an app
@@ -34,20 +34,11 @@ import { leanToolResultForModel } from "./lean.js";
  * render (inline card, focus, …). These rows carry no `metadata.name`, so the tool is
  * minted under the component id and deduped across rows pointing at the same app.
  *
- * App descriptions gain the INTERACTIVE-APP etiquette so the model promotes the UI
- * instead of answering alongside it (observed live: a full interview streamed next to
- * the wizard asking the same questions).
+ * App descriptions gain one sentence of etiquette; the schema is the instruction channel.
  */
 export const APP_ETIQUETTE =
-  "INTERACTIVE APP: calling this renders a UI the user " +
-  "completes on screen. When you call it, reply with at most ONE short sentence inviting the user to it — " +
-  "never answer the request in text alongside it, never list options, never ask questions the app will " +
-  "collect. If the result includes `output`, those are the user's complete answers — continue the task " +
-  "with them (search if the request needs a lookup) and only then answer. " +
-  "If your instructions include background about this user, every text field you compose here is written " +
-  "FOR that person — use their name and what you know about them in headlines, intros, and copy; " +
-  "generic audience-neutral brochure copy is wrong when you know who is reading.";
-
+  "INTERACTIVE APP: calling this puts a UI on screen that the user completes there; reply with one short sentence inviting them to it, and when the result carries `output` those are their answers, so continue with them. " +
+  "Text you compose here is written for this person when you know who they are.";
 
 export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[] {
   const discovered: DiscoveredMCP[] = [];
@@ -60,11 +51,52 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
     const results = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.results) ? parsed.results : null;
     if (!results) continue;
     for (const item of results) {
-      if (item?.object_type !== "mcp") continue;
-      if (item.metadata?.schema?.methods) {
+      // Two row types mint tools: the registry family (stored "mcp": components, apps,
+      // node-MCPs) and TASKS (an outcome with a door, docs/unoverse/data/objects/elements/task.md).
+      if (item?.object_type !== "mcp" && item?.object_type !== "task") continue;
+      // WHAT KIND OF STEP a call to it will be on the timeline: a task is an outcome the
+      // person can get done, and the viewer draws it as one rather than as a bare tool.
+      const isTask = item.object_type === "task";
+      if (item.object_type === "task" && item.metadata?.workflow && item.metadata?.trigger && item.metadata?.output) {
+        // A WORKFLOW TASK: a task-augmented native tool on the platform's own /mcp
+        // (server mcp/server/taskTools.ts). Calling it fires the Agent and HOLDS until the
+        // run completes; the terminal node's output is the result. `taskTool` is the tool's
+        // identity (`<org>/<name>`), which the wire call spells dotted.
+        const methodName = item.metadata.name;
+        if (!methodName) continue;
+        const input = item.metadata.inputSchema || { type: "object", properties: { message: { type: "string" } } };
+        // What to do rides the tool description: the only channel that reaches a model for a
+        // tool minted mid-conversation. The skills it names are loaded through readSkill as usual.
+        const skills = Array.isArray(item.metadata?.skills) && item.metadata.skills.length ? ` Skills required: ${item.metadata.skills.join(", ")} (read them with readSkill first).` : "";
+        // 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
+        // (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.
+        //
+        // Nothing replaces it. Tool calling is native to these models, and the etiquette was
+        // us describing a heavyweight thing with consequences — holds, progress, watch — where
+        // a tool description should say what the tool does and what it returns. What the
+        // AUTHOR wrote stands on its own; add words back only if a measurement asks for them.
+        const taskDescription = `${item.description || item.title || methodName}${item.metadata?.instructions ? ` ${item.metadata.instructions}` : ""}${skills}`;
+        discovered.push({
+          ...(isTask ? { task: true as const } : {}),
+          id: item.id || item.universal_id,
+          title: item.title || "",
+          description: taskDescription,
+          workflowId: item.metadata.workflow || item.workflow_id,
+          nodeId: item.metadata.trigger,
+          methodName,
+          taskTool: String(methodName),
+          schema: { methods: { [methodName]: { description: taskDescription, input } } },
+        });
+      } else if (item.metadata?.schema?.methods) {
         const methodName = Object.keys(item.metadata.schema.methods)[0];
         if (!methodName) continue;
         discovered.push({
+          ...(isTask ? { task: true as const } : {}),
           id: item.id || item.universal_id,
           title: item.title || "",
           description: item.description || "",
@@ -80,6 +112,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
         const input = item.metadata.inputSchema || { type: "object", properties: { message: { type: "string" } } };
         const appDescription = `${item.description || item.title || methodName} ${APP_ETIQUETTE}`;
         discovered.push({
+          ...(isTask ? { task: true as const } : {}),
           id: item.id || item.universal_id,
           title: item.title || "",
           description: appDescription,
@@ -90,7 +123,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
         });
       } else if (item.metadata?.app && !item.metadata?.workflow) {
         // PATH B — bindingless component app: no workflow. Minted like an app tool; the
-        // adapter passes `component` to `invokeComponentAppNative` (held native `/mcp`
+        // adapter passes `component` to `invokeTaskNative` (held native `/mcp`
         // call → the SERVER renders + elicits) instead of firing. The row carries NO
         // schema — the input schema is pulled LIVE from `<appUri>/schema` at mint time
         // (`resolveToolDefNative`); this default is the un-briefed fallback only.
@@ -99,6 +132,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
         const input = { type: "object", properties: {} };
         const appDescription = `${item.description || item.title || methodName} ${APP_ETIQUETTE}`;
         discovered.push({
+          ...(isTask ? { task: true as const } : {}),
           id: item.id || item.universal_id,
           title: item.title || "",
           description: appDescription,
@@ -130,7 +164,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
  * DISCOVERY NEVER CALLS THE APP. Finding a component in search results is not someone
  * asking for it; only the model's own tool call is. Two fire-and-forget calls lived here
  * (a shell-open on unlock, a draft top-up when a later search carried images) to paint a
- * composed page's frame early. Both were `invokeComponentAppNative`, so on an app whose
+ * composed page's frame early. Both were `invokeTaskNative`, so on an app whose
  * component declares `outputs` each one rendered the component AND opened its own
  * elicitation: observed live 2026-08-10, three renders and three concurrent forms in ONE
  * turn, of which the channel can hold only one (connection.tsx keeps a single pending
@@ -162,6 +196,30 @@ export async function handleDiscoveryResult(
   return leanToolResultForModel(resultContent);
 }
 
+/**
+ * THE FUNCTIONS THE RESULT'S ROWS OFFER, lifted off the search envelope before the lean drops the
+ * key. The engine wrote them once per name (`functions: { getDetail: { description, input,
+ * objects } }`); each becomes a tool the moment the row that offers it is found, and the model
+ * never reads the key as data. Not a discovery tool's reply, or a reply without the key: nothing.
+ */
+export function parseOfferedFunctions(toolName: string, resultContent: string): OfferedFunction[] {
+  if (!DISCOVERY_TOOL_NAMES.includes(toolName)) return [];
+  const parsed = parseToolResult(resultContent);
+  const fns = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as { functions?: unknown }).functions : null;
+  if (!fns || typeof fns !== "object" || Array.isArray(fns)) return [];
+  const out: OfferedFunction[] = [];
+  for (const [name, raw] of Object.entries(fns as Record<string, any>)) {
+    if (!name || !raw || typeof raw !== "object") continue;
+    out.push({
+      name,
+      description: typeof raw.description === "string" ? raw.description : "",
+      ...(raw.input && typeof raw.input === "object" && !Array.isArray(raw.input) ? { input: raw.input as Record<string, unknown> } : {}),
+      objects: Array.isArray(raw.objects) ? raw.objects.filter((o: unknown) => typeof o === "string") : [],
+    });
+  }
+  return out;
+}
+
 /**
  * THE SKILLS THE SEARCH SAID ARE IN FORCE where this query landed.
  *

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

@@ -1,9 +1,9 @@
 /**
  * DOES THIS TOOL CALL END THE TURN?
  *
- * Decided by PROVENANCE and RESULT SHAPE, never by a hardcoded list of tool names. A tool
- * wired in up front keeps the conversation going; one spatial surfaced mid-loop is a handoff
- * candidate, and whether it actually ends the turn depends on what came back.
+ * Decided by PROVENANCE and RESULT SHAPE, never by a hardcoded list of tool names. The
+ * bridge knows which minted tools are workflow handoffs; whether one actually ends the
+ * turn depends on what came back.
  */
 import type { AgentToolExchange } from "./types.js";
 
@@ -16,39 +16,19 @@ export function parseToolResult(content: string): any {
   }
 }
 
-/**
- * Whether any tool call is a dynamically-discovered workflow handoff.
- *
- * Provenance, not a hardcoded name list: a tool keeps the conversation going if it
- * was wired in up front (`coreToolNames`, the getSchema set — SpatialSearch, memory,
- * connector MCPs). Only tools spatial surfaced mid-loop are handoff candidates.
- * With no wired-tool info we can't identify a handoff, so we keep going.
- */
-export function hasDynamicHandoff(toolNames: string[], coreToolNames?: Set<string>): boolean {
-  if (!coreToolNames || coreToolNames.size === 0) return false;
-  return toolNames.some((name) => !coreToolNames.has(name));
-}
-
 /**
  * Whether this batch of tool calls ENDS the agent's turn.
  *
- * Refined by RESULT shape: a dynamically-discovered tool whose result carries
- * `output` (or an explicit completed/error status) is an interactive app's SLOW
- * CALL — the user completed it and the answers ARE the result; the conversation
- * CONTINUES with them. Only the fire-and-forget handoff signature
- * ({ status: "started" } / unparseable) ends the turn.
+ * Only a tool in `handoffTools` can — a workflow-bound app fired through the service lane,
+ * whose result is the fire-and-forget signature ({ status: "started" } / unparseable). A
+ * result carrying `output` (or an explicit completed/error status) is a held call that
+ * came back with the answers, and the conversation continues with them. A component app, a
+ * workflow task or a platform tool is never a handoff, whatever it returns.
  */
-export function isTurnEndingHandoff(calls: AgentToolExchange[], coreToolNames?: Set<string>): boolean {
-  if (
-    !hasDynamicHandoff(
-      calls.map((c) => c.name),
-      coreToolNames,
-    )
-  ) {
-    return false;
-  }
+export function isTurnEndingHandoff(calls: AgentToolExchange[], handoffTools?: Set<string>): boolean {
+  if (!handoffTools?.size) return false;
   return calls.some((c) => {
-    if (coreToolNames?.has(c.name)) return false;
+    if (!handoffTools.has(c.name)) return false;
     const res = parseToolResult(c.resultContent);
     if (res && typeof res === "object" && (res.output || res.status === "completed" || res.status === "error")) return false;
     return true;

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

@@ -33,12 +33,12 @@ export type {
   AppInvocationContext,
 } from "./types.js";
 
-export { DISCOVERY_TOOL_NAMES, APP_ETIQUETTE, parseDiscoveredMCPs, handleDiscoveryResult, parseRegionSkills, type LoadedRegionSkill } from "./discovery.js";
-export { parseToolResult, hasDynamicHandoff, isTurnEndingHandoff } from "./handoff.js";
-export { rowComponentsFromResults, renderRowComponents, rankedRowIds, componentTypeFromAppUri, onEmptyRowDelivery } from "./rowComponents.js";
+export { DISCOVERY_TOOL_NAMES, APP_ETIQUETTE, parseDiscoveredMCPs, handleDiscoveryResult, parseRegionSkills, parseOfferedFunctions, type LoadedRegionSkill } from "./discovery.js";
+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, modelToolName } from "./tools.js";
-export { invokeComponentAppNative, connectPlatformMcp } from "./invoke.js";
+export { toolDefFromDiscoveredMCP, resolveToolDefNative, isBindinglessComponentApp, componentAppInvoker, isWorkflowTask, workflowTaskInvoker, workflowAppInvoker, modelToolName, objectFunctionToolDef, objectFunctionInvoker } from "./tools.js";
+export { invokeTaskNative, connectPlatformMcp } from "./invoke.js";
 
 export { ingestConversationTurn, type ConversationTurn } from "./memoryIngest.js";
 export { fetchUserMemoryContext, hydratePromptWithUserMemory } from "./memoryContext.js";

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

@@ -2,12 +2,14 @@
  * THE ONE WIRE CALL. Where our code ends and native MCP begins.
  *
  * Everything else in this folder is interpretation and routing that never touches the MCP
- * wire. This is the exception: `invokeComponentAppNative` opens a client and makes a real
- * `tools/call`. From there the server renders, elicits, and its answers resolve the call.
+ * wire. This is the exception: `invokeTaskNative` opens a client and makes a real
+ * `tools/call`. From there the server renders, elicits, runs, and its answers resolve the call.
  *
- * Node-MCP rows and path-A workflow apps do NOT come through here — they route in-process
- * via the caller's `api.callService`, because they have a node or a workflow to run. Only a
- * path-B component app, with nothing local to call, rides the wire.
+ * TWO KINDS OF TASK ride it (2026-09-06, "every task is a native MCP tool"): a component
+ * app (path B: the server renders and elicits) and a WORKFLOW TASK (the server fires the
+ * Agent and holds the call until the run completes; the terminal output is the result).
+ * Node-MCP rows still route in-process via the caller's `api.callService`: they have a
+ * node to run. Renamed from `invokeComponentAppNative` when workflow tasks joined it.
  */
 import type { AppInvocationContext, DiscoveredMCP } from "./types.js";
 
@@ -68,7 +70,7 @@ export async function connectPlatformMcp(
   };
 }
 
-export async function invokeComponentAppNative(
+export async function invokeTaskNative(
   toolId: string,
   ctx: AppInvocationContext,
 ): Promise<{ status: "completed"; output?: Record<string, unknown>; conversationId?: string; action?: string; message?: string }> {
@@ -87,24 +89,44 @@ export async function invokeComponentAppNative(
           ...(ctx.instanceId ? { instanceId: ctx.instanceId } : {}),
           ...(ctx.fromRow ? { fromRow: true } : {}),
           ...(ctx.shell ? { shell: true } : {}),
+          ...(typeof ctx.rank === "number" ? { rank: ctx.rank } : {}),
           ...(ctx.batch ? { batch: ctx.batch } : {}),
+          // A workflow task's own arguments, as the model wrote them against the task's schema.
+          ...(ctx.args ?? {}),
         },
       },
       undefined,
-      // A human is completing the wizard — lift the SDK's 60s default to 24h.
+      // A human is completing the wizard, or an Agent is working — lift the SDK's 60s default to 24h.
       { timeout: 24 * 60 * 60 * 1000 },
     )) as {
       isError?: boolean;
       content?: Array<{ type: string; text?: string }>;
-      structuredContent?: { output?: Record<string, unknown>; conversationId?: string; action?: string };
+      structuredContent?: { output?: Record<string, unknown>; conversationId?: string; action?: string; result?: string; executionId?: string; status?: string };
     };
     // A handler exception arrives as an isError RESULT, not a rejection — surface it, or a
     // broken run masquerades as "completed with no output".
     if (result.isError) {
       throw new Error(result.content?.find((c) => c.type === "text")?.text || `${toolId} app tool call failed`);
     }
-    const output = result.structuredContent?.output;
+    // THE ANSWER IS THE RESULT (2026-09-15): a component that asks returns `structuredContent`
+    // conforming to its `outputSchema`, with no envelope. Older shapes keep `output` inside one.
+    const sc = result.structuredContent as Record<string, unknown> | undefined;
+    const bare = !!sc && sc.output === undefined && sc.app === undefined && sc.result === undefined && sc.rendered === undefined;
+    const output = bare ? sc : result.structuredContent?.output;
     const resultText = result.content?.find((c) => c.type === "text")?.text;
+    // A WORKFLOW TASK resolved: the Agent's run completed and `result` is its terminal
+    // output (server mcp/server/taskRun.ts). Handed to the model as `output.result` with
+    // the instruction that this IS the answer to use, not a profile to search with.
+    if (typeof result.structuredContent?.result === "string") {
+      return {
+        status: "completed",
+        output: { result: result.structuredContent.result },
+        conversationId: result.structuredContent?.conversationId,
+        message:
+          "The Agent completed. `output.result` is what it found, already shown to the person on screen. " +
+          "Continue the task with it: answer from it, and do not repeat it verbatim unless asked.",
+      };
+    }
     // BRIEFED component result (output carries `rendered`): the TEXT is the instruction
     // channel — the referee's "NOT RENDERED — <violations>" correction or the mirror's
     // "Rendered. The guest now sees this page…" reflection. Pass it through VERBATIM so
@@ -128,18 +150,14 @@ export async function invokeComponentAppNative(
       // live: card streamed in, then no follow-up text, twice).
       status: "completed",
       output,
-      conversationId: result.structuredContent?.conversationId,
+      conversationId: result.structuredContent?.conversationId ?? ctx.conversationId,
       action: result.structuredContent?.action,
-      // Tell the calling model what the output MEANS and that the task is NOT done yet.
-      // Without this the model summarises the answers and stops instead of using them —
-      // observed live: it returned a generic reply and never re-searched (iteration with
-      // toolCalls:0). The legacy MCPInvoker returned this same guidance; dropping it in the
-      // de-fork is why "the model does nothing with the answers". Restores the behaviour.
+      // THE ANSWER IS THE RESULT (2026-09-15, native elicitation): what each field means was
+      // declared on the tool's `outputSchema` and read before the call. Nothing is said here.
+      // A fixed "search now with this profile" sentence lived in this spot; it turned a
+      // chosen card into a search query.
       ...(output && Object.keys(output).length
-        ? {
-            message:
-              "`output` is the user's complete profile collected by the app — do NOT ask for any of these values again. The user's request is NOT yet fulfilled: any earlier search predates these answers. Search NOW with a query built from this profile and recommend the specific matches you find.",
-          }
+        ? {}
         : {
             message:
               "The component is now displayed on the user's screen. Continue your answer for the user now — the render is a visual aid, not your reply.",

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

@@ -36,6 +36,11 @@ const MODEL_METADATA_FIELDS = [
   "category",
   "whenToUse",
   "section",
+  // A TASK row (object_type task): its identity URI and what its face says while it runs.
+  // The door fields (workflow, trigger, output) are read from the RAW row by the harness
+  // at mint time, never by the model.
+  "task",
+  "message",
 ] as const;
 
 /**
@@ -54,6 +59,14 @@ export function leanToolResultForModel(resultContent: string): string {
       // THE SEARCH'S MIRROR (MCP_APP_PROTOCOL §0.1): what the delivery put on screen. The
       // one key the model must read before the rows; kept verbatim.
       ...(typeof parsed.screen === "string" && parsed.screen ? { screen: parsed.screen } : {}),
+      // THE TOOLS THESE ROWS BROUGHT (objects-in-spatial.md, "Found objects' functions as tools").
+      // The harness minted them a moment ago; a tool minted mid-conversation reaches the model
+      // through its description alone, and observed 2026-09-16 that was not enough on a long
+      // conversation: the model answered from the rows with the tool on offer. Named here, in
+      // the reply it is reading, before the rows.
+      ...(parsed.functions && typeof parsed.functions === "object" && !Array.isArray(parsed.functions) && Object.keys(parsed.functions).length
+        ? { tools: Object.entries(parsed.functions as Record<string, any>).map(([tool, f]) => ({ tool, offeredBy: Array.isArray(f?.objects) ? f.objects : [], does: typeof f?.description === "string" ? f.description : "", call: "with a result's universal_id" })) }
+        : {}),
       results: parsed.results.map((r: Record<string, any>) => {
         const m = (r.metadata ?? {}) as Record<string, unknown>;
         const meta: Record<string, unknown> = {};
@@ -74,6 +87,9 @@ export function leanToolResultForModel(resultContent: string): string {
           description: r.description,
           ...(r.key_need ? { key_need: r.key_need } : {}),
           object_type: r.object_type,
+          // WHICH OF THE TWELVE IT IS (objects README 4a): the search route stamps it, the
+          // node keeps it, and this projection runs last, so it must keep it too.
+          ...(r.element ? { element: r.element } : {}),
           // One relevance number per mode: similarity (intent) or distance (discovery).
           ...(typeof r.similarity === "number" ? { similarity: r.similarity } : {}),
           ...(typeof r.distance === "number" ? { distance: r.distance } : {}),
@@ -83,6 +99,9 @@ export function leanToolResultForModel(resultContent: string): string {
           // 12 chars: cheaper than the URL it complements.
           ...(r.source_id ? { source_id: r.source_id } : {}),
           hasImage,
+          // ITS LINES, by name (migration 051): a need's `of` is what it was read from, a part's
+          // `partOf` its whole. They let rows be joined without a read.
+          ...(r.links && typeof r.links === "object" && Object.keys(r.links).length ? { links: r.links } : {}),
           ...(Object.keys(meta).length ? { metadata: meta } : {}),
         };
       }),