@unoverse-platform/studio 0.1.115 → 0.1.117

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

@@ -140,3 +140,30 @@ export function sessionTurnRecorder(
     flush: save,
   };
 }
+
+/**
+ * THE TASK THE APP'S ADDRESS NAMES, in the call before it starts (docs/mcp/MCP_TASKS.md § 5c).
+ * A task found in Spatial lands in the conversation as the search's result, so the model knows
+ * it; a task opened by an address has no search, so what it holds is replayed instead, read by
+ * its id with the official client (`tasks/get`), the same way the memory block above is. Only an
+ * id: a URI (`<org>/<name>`, which a task's own run also carries) is not an opened task.
+ */
+export async function hydrateOpenedTask(config: any, executionContext: any): Promise<any> {
+  const id = executionContext?.publishingContext?.task;
+  if (typeof id !== "string" || !id || id.includes("/")) return config;
+  try {
+    const harness: any = await import("../../agent-mcp/index.js");
+    const task = await harness.readTask(id, { accessToken: executionContext?.auth?.accessToken });
+    const block =
+      `This conversation was opened on a task (${task.status}).` +
+      (task.statusMessage ? ` ${task.statusMessage}` : "") +
+      (task.asks ? `\nIt asks: ${JSON.stringify(task.asks)}` : "") +
+      (task.result ? `\nWhat it holds:\n${task.result}` : "");
+    const history = Array.isArray(config?.conversationHistory) ? config.conversationHistory : [];
+    console.log(`[manifests] opened task ${id} replayed into the call (${task.status})`);
+    return { ...config, conversationHistory: [...history, { role: "user", content: block }] };
+  } catch (e: any) {
+    console.log(`[manifests] opened task ${id} could not be read (non-blocking): ${e?.message ?? e}`);
+    return config;
+  }
+}

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

@@ -12,6 +12,7 @@
 import type { ToolBridge } from "../runtime/index.js";
 import { engineUrl } from "./context.js";
 import { saveAvailableTools } from "../../platform/serviceCalls.js";
+import { recordCall } from "../runtime/tools/toolloop.js";
 
 /** The screen's verbs on an app with places (docs/unoverse/design/screen/UNOVERSE_SCREEN.md §3.3). */
 const SCREEN_VERBS = {
@@ -60,6 +61,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 +82,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.
@@ -176,24 +183,82 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
     }
   }
 
-  return {
+  /**
+   * THE TASK THE APP'S ADDRESS NAMES, by its id (docs/mcp/MCP_TASKS.md § 5c). An edge or Spatial
+   * hands the model a task to start; an id names one that already exists, connected through the
+   * official client's `session.task(id)`. The model can read it, and answer it while it waits:
+   * the two things MCP offers on an existing task. A URI (`<org>/<name>`, which a task's own run
+   * also carries) is not this. Fail-soft: a task that cannot be read adds nothing.
+   */
+  const named = pub?.task;
+  if (typeof named === "string" && named && !named.includes("/")) {
+    try {
+      const now = await harness.readTask(named, identity);
+      appInvokers.set("read_task", () => harness.readTask(named, identity));
+      preMinted.push({
+        name: "read_task",
+        description: `The task this conversation was opened on (${now.status}). Read it for where it is, what it asks and what it produced.`,
+        parameters: { type: "object", properties: {} },
+      });
+      if (now.status === "input_required") {
+        appInvokers.set("answer_task", async (input: any) => {
+          await harness.answerTask(named, (input?.answers ?? {}) as Record<string, unknown>, identity);
+          return harness.readTask(named, identity);
+        });
+        preMinted.push({
+          name: "answer_task",
+          description: "Answer what the task this conversation was opened on asks, each answer under the key it asks with.",
+          parameters: { type: "object", properties: { answers: { type: "object", description: "Each answer under the key the task asks with." } }, required: ["answers"] },
+        });
+      }
+      console.log(`[manifests] task ${named} connected (${now.status})`);
+    } catch (e: any) {
+      console.log(`[manifests] task ${named} could not be read: ${e?.message ?? e}`);
+    }
+  }
+
+  /** The tools held behind search_tools on this run, or null when every tool is offered. */
+  let held: Array<{ name: string; description: string; parameters: unknown; server?: string }> | null = null;
+
+  const bridge: ToolBridge = {
     async discover() {
-      const tools = [
-        ...Object.entries<any>(schema.methods).map(([name, m]) => ({
-          name,
-          description: m.description || `Execute ${name}`,
-          parameters: m.input || { type: "object", properties: {} },
-        })),
-        ...preMinted,
-      ];
+      const wired = Object.entries<any>(schema.methods).map(([name, m]) => ({
+        name,
+        description: m.description || `Execute ${name}`,
+        parameters: m.input || { type: "object", properties: {} },
+        ...(m.server ? { server: String(m.server) } : {}),
+      }));
+      // MANY TOOLS ARE HELD BEHIND SEARCH (harness.shouldDefer, MCP Client Best Practices). Spatial
+      // search stays offered: it is how an Agent finds what it does not hold, and what it finds is
+      // minted as a tool. The screen and open pages (preMinted) are never held.
+      const deferrable = wired.filter((t) => !harness.DISCOVERY_TOOL_NAMES.includes(t.name));
+      held = harness.shouldDefer(deferrable) ? deferrable : null;
+      if (held) console.log(`[manifests] ${held.length} tools held behind ${harness.SEARCH_TOOLS} (about ${harness.estimateTokens(held)} tokens of definitions)`);
+      const strip = ({ server: _server, ...t }: any) => t;
+      const tools = [...(held ? [...wired.filter((t) => !held!.includes(t)), ...harness.metaTools(held)] : wired).map(strip), ...preMinted];
       // Everything the model starts with, the screen and open pages included.
       if (caller.executionId && caller.nodeId) saveAvailableTools(caller.executionId, caller.nodeId, tools.map((t) => t.name));
       return tools;
     },
 
-    async call(name, args) {
+    async call(name, args, hooks): Promise<string> {
+      // A SEARCH IS A CALL LIKE ANY OTHER, recorded on the run with what it asked and what it found:
+      // without it nobody could see which tools an Agent looked for, or why it never used one.
+      if (held && name === harness.SEARCH_TOOLS) {
+        const startTime = Date.now();
+        const answer = harness.searchAnswer(held, args?.query);
+        recordCall({ executionId: caller.executionId, parentNodeId: caller.nodeId, toolName: harness.SEARCH_TOOLS, args, result: answer, startTime, success: true, who: "harness" });
+        return answer;
+      }
+      // A held tool, called by name. Only a tool this Agent was given: the list is its limit.
+      if (held && name === harness.CALL_TOOL) {
+        const target = String(args?.name ?? "");
+        if (!held.some((t) => t.name === target)) return JSON.stringify({ error: `No tool named "${target}". Find it with ${harness.SEARCH_TOOLS} first.` });
+        return bridge.call(target, args?.arguments ?? {}, 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
@@ -269,7 +334,7 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
               // A WORKFLOW-BOUND APP (path A) OPENS, then ends the turn. It used to only end
               // the turn: nothing registered an invoker, so the model's call fell through to
               // `api.callService` and died as an unknown SERVICE method while the run reported
-              // success and the screen stayed blank (SAB, 2026-09-07). Both, in this order —
+              // success and the screen stayed blank (a bank, 2026-09-07). Both, in this order —
               // the app tool renders the surface and fires no workflow itself (server
               // mcp/server/tools.ts), so the handoff that follows is not a second run.
               appInvokers.set(def.name, harness.workflowAppInvoker(mcp, called));
@@ -308,4 +373,5 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
       return harness.isTurnEndingHandoff(calls, handoffTools);
     },
   };
+  return bridge;
 }

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/auth/oauth.ts

@@ -1,6 +1,6 @@
 /**
- * OAUTH2 CLIENT CREDENTIALS. An auth scheme, so it is written once here rather than in
- * every node that needs it (DECLARATIVE_NODES.md §2).
+ * OAUTH2 CLIENT CREDENTIALS AND REFRESH TOKENS. Auth schemes, so they are written once here
+ * rather than in every node that needs them (DECLARATIVE_NODES.md §2).
  *
  * Unlike a bearer key, this is not a value the manifest can template: the credential is a
  * client id and secret that must be EXCHANGED for a short-lived token, over a form-encoded
@@ -10,7 +10,15 @@
  * The token response is put back into scope as `token`, because some vendors return where
  * to talk as well as how. Salesforce returns `instance_url` and the org's API lives there,
  * not at the login host you authenticated against.
+ *
+ * A REFRESH TOKEN is the same exchange with one more secret. Some vendors (LinkedIn) never
+ * issue a token to an app alone: a person approves the app once, and what that leaves behind
+ * is a long-lived refresh token the app trades for short-lived access tokens with nobody
+ * signed in. The person makes it once in the vendor's developer portal and it is pasted into
+ * the credential, as the client secret is.
  */
+import { createHash } from "node:crypto";
+
 
 interface Minted {
   accessToken: string;
@@ -22,16 +30,23 @@ interface Minted {
  * Cached per connected-app identity, not per node or per run.
  *
  * A workflow that makes six calls must not mint six tokens, and a vendor will rate-limit or
- * refuse if it does. Keyed by client id AND token url so two orgs never share an entry.
+ * refuse if it does. Keyed by client id AND token url so two orgs never share an entry, and
+ * for a refresh token by that token too: two orgs may connect through the same vendor app.
  */
 const CACHE = new Map<string, Minted>();
 
 /** Default life. Salesforce client-credentials sessions are ~2h; refresh well before. */
 const DEFAULT_TTL_MS = 110 * 60 * 1000;
 
+function cacheKey(tokenUrl: string, clientId: string, refreshToken?: string): string {
+  // A digest, never the refresh token itself, so the key holds no secret.
+  const who = refreshToken ? `#${createHash("sha256").update(refreshToken).digest("hex").slice(0, 16)}` : "";
+  return `${clientId}@${tokenUrl}${who}`;
+}
+
 /** Drop a cached token, so the next call mints a fresh one. */
-export function invalidateToken(tokenUrl: string, clientId: string): void {
-  CACHE.delete(`${clientId}@${tokenUrl}`);
+export function invalidateToken(tokenUrl: string, clientId: string, refreshToken?: string): void {
+  CACHE.delete(cacheKey(tokenUrl, clientId, refreshToken));
 }
 
 export async function mintClientCredentials(
@@ -41,15 +56,33 @@ export async function mintClientCredentials(
   scope: string | undefined,
   force = false,
 ): Promise<Minted> {
-  const key = `${clientId}@${tokenUrl}`;
+  const form = new URLSearchParams({ grant_type: "client_credentials", client_id: clientId, client_secret: clientSecret });
+  if (scope) form.set("scope", scope);
+  return mint("oauth2ClientCredentials", tokenUrl, form, cacheKey(tokenUrl, clientId), force);
+}
+
+export async function mintFromRefreshToken(
+  tokenUrl: string,
+  clientId: string,
+  clientSecret: string,
+  refreshToken: string,
+  force = false,
+): Promise<Minted> {
+  const form = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: clientId,
+    client_secret: clientSecret,
+  });
+  return mint("oauth2RefreshToken", tokenUrl, form, cacheKey(tokenUrl, clientId, refreshToken), force);
+}
+
+async function mint(scheme: string, tokenUrl: string, form: URLSearchParams, key: string, force: boolean): Promise<Minted> {
   const hit = CACHE.get(key);
   if (!force && hit && hit.expiresAt > Date.now()) return hit;
 
   // FORM ENCODED, not JSON. The OAuth2 spec says so and vendors enforce it, which is why
   // this cannot ride the ordinary body path: that one always sends JSON.
-  const form = new URLSearchParams({ grant_type: "client_credentials", client_id: clientId, client_secret: clientSecret });
-  if (scope) form.set("scope", scope);
-
   const res = await fetch(tokenUrl, {
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
@@ -61,7 +94,7 @@ export async function mintClientCredentials(
     // The description, not just the status: "invalid_client" tells you which of the two
     // secrets is wrong, and a bare 400 does not.
     const detail = data?.error_description ?? data?.error ?? res.statusText;
-    throw new Error(`oauth2ClientCredentials: token request to ${tokenUrl} failed (${res.status}): ${detail}`);
+    throw new Error(`${scheme}: token request to ${tokenUrl} failed (${res.status}): ${detail}`);
   }
 
   const minted: Minted = {

package/vendor/base/src/manifests/runtime/events.ts

@@ -211,7 +211,7 @@ export function makeEmitter(node: ComposedNode, onEmit: (e: Emission) => void, b
      * word after the first sitting in `pending`, and the next thing to move it is whatever
      * arrives next, however much later.
      *
-     * Seen live (SAB Account Agent, 2026-09-08): the model said "I'm checking your account
+     * Seen live (a bank's account agent, 2026-09-08): the model said "I'm checking your account
      * activity for food spending last month" in a few milliseconds, the reader saw "I", and
      * the rest appeared eleven seconds afterwards — when a delta from the turn AFTER the
      * tool call finally pushed it out. It read as the stream stopping for the tool. It was

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

@@ -10,7 +10,7 @@ import { render, evaluate, primeTemplating } from "../templating.js";
 import { assertAllowedHost } from "./allowedHosts.js";
 import { readSettled, assertOk } from "./response.js";
 import { performState, type StateStore } from "../state.js";
-import { mintClientCredentials, invalidateToken } from "../auth/oauth.js";
+import { mintClientCredentials, mintFromRefreshToken, invalidateToken } from "../auth/oauth.js";
 import { signAwsRequest, presignAwsUrl, encodeDynamoJson, decodeDynamoJson, type AwsSigning } from "../auth/aws.js";
 import { fetchPaginated } from "../loops/paginate.js";
 import { fetchPolled } from "../loops/poll.js";
@@ -116,6 +116,17 @@ export async function buildRequest(
       scoped = { ...ctx, token: { instanceUrl: minted.instanceUrl } } as RunContext;
       break;
     }
+    case "oauth2RefreshToken": {
+      const minted = await mintFromRefreshToken(
+        await required(auth.tokenUrl, "a token url"),
+        await required(auth.clientId, "a client id"),
+        await required(auth.clientSecret, "a client secret"),
+        await required(auth.refreshToken, "a refresh token"),
+        forceReauth,
+      );
+      authHeaders.Authorization = `Bearer ${minted.accessToken}`;
+      break;
+    }
     case "awsSigV4": {
       // The manifest names the SERVICE and the REGION, because those decide what the
       // signature is scoped to and they are properties of the endpoint being described.
@@ -237,6 +248,15 @@ async function resolveValue(value: any, ctx: RunContext): Promise<unknown> {
  * A timeout is an ERROR, not an empty result: it fails with a message naming the limit and the call,
  * so the manifest's own number appears in the log that reports it.
  */
+/** How many times a call whose connection dropped is made again: 2s, 4s, 8s, 16s, 32s, 60s, 60s, 60s, 60s, about five minutes. */
+export const DROPPED_RETRIES = 9;
+/** A failure with no reply at all: the connection dropped, was refused, reset, or never resolved. Never a status. */
+export function dropped(error: any): boolean {
+  const code = String(error?.cause?.code ?? error?.code ?? "");
+  const text = String(error?.message ?? error);
+  return /^(ECONNRESET|ECONNREFUSED|EAI_AGAIN|ENOTFOUND|EPIPE|ETIMEDOUT|UND_ERR_SOCKET|UND_ERR_CONNECT_TIMEOUT)$/.test(code) || /^fetch failed$/i.test(text) || /socket hang up|other side closed/i.test(text);
+}
+
 export async function fetchWithTimeout(url: string, init: any, timeoutMs: unknown, label: string): Promise<Response> {
   const ms = typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : 0;
   if (!ms) return fetch(url, init);
@@ -408,6 +428,21 @@ export async function sendRequest(node: ComposedNode, requestSpec: any, ctx: Run
     waiter?.unref?.();
     try {
       res = await fetchWithTimeout(url, init, requestSpec?.timeoutMs, label);
+    } catch (error: any) {
+      /**
+       * A DROPPED CONNECTION IS ASKED AGAIN (2026-10-22). A host that scales to zero answers its first
+       * call by booting; the gateway in front of it drops the connection while a model loads (NuExtract
+       * on Beam: four and a half minutes), and the engine saw "fetch failed" with no status at all. That
+       * is not the vendor's answer, it is no answer, so the call is made again with a growing wait, up
+       * to about five minutes in all. A reply with a status, good or bad, is never retried here.
+       */
+      if (dropped(error) && attempt <= DROPPED_RETRIES) {
+        const wait = Math.min(60_000, 2_000 * 2 ** (attempt - 1));
+        console.warn(`[manifests] ${label}: the connection dropped (${String(error?.cause?.code ?? error?.message ?? error).slice(0, 80)}); asking again in ${Math.round(wait / 1000)}s (${attempt}/${DROPPED_RETRIES})`);
+        await new Promise((r) => setTimeout(r, wait));
+        continue;
+      }
+      throw error;
     } finally {
       if (waiter) clearInterval(waiter);
     }
@@ -428,8 +463,13 @@ export async function sendRequest(node: ComposedNode, requestSpec: any, ctx: Run
     // A minted token can be revoked or expire early, and the vendor says so with a 401.
     // Refresh ONCE and retry, exactly as the retired client did. Guarded by !forceReauth so
     // a genuinely rejected credential fails rather than looping.
-    if (res.status === 401 && requestSpec?.credential?.scheme === "oauth2ClientCredentials" && !forceReauth) {
-      invalidateToken(String(render(requestSpec.credential.tokenUrl, ctx)), String(render(requestSpec.credential.clientId, ctx)));
+    const scheme = requestSpec?.credential?.scheme;
+    if (res.status === 401 && (scheme === "oauth2ClientCredentials" || scheme === "oauth2RefreshToken") && !forceReauth) {
+      invalidateToken(
+        String(render(requestSpec.credential.tokenUrl, ctx)),
+        String(render(requestSpec.credential.clientId, ctx)),
+        scheme === "oauth2RefreshToken" ? String(render(requestSpec.credential.refreshToken, ctx)) : undefined,
+      );
       console.warn(`[manifests] ${label}: 401, refreshing the access token and retrying once`);
       return sendRequest(node, requestSpec, ctx, label, true);
     }
@@ -512,8 +552,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) {

package/vendor/base/src/manifests/runtime/loops/poll.ts

@@ -141,12 +141,34 @@ export async function fetchPolled(
     `[manifests] ${label}: job started — polling ${url.split("?")[0]} every ${Math.round(interval / 1000)}s (up to ${attempts} attempts)`,
   );
 
+  // THE FIRST CHECKS COME QUICKLY (2026-10-25): one second, then two, four, doubling up to the manifest's interval. A job
+  // answered from the vendor's cache is ready at once, and a fixed ten-second wait before the first check made every
+  // stored parse take ten seconds; a long job still settles into the full interval, so its patience is barely shorter.
+  let wait = Math.min(1000, interval);
   for (let attempt = 1; attempt <= attempts; attempt++) {
-    await new Promise((r) => setTimeout(r, interval));
-
-    const res = await sendRequest(node, statusCall, ctx, `${label} (poll ${attempt}/${attempts})`);
-    const payload = await readSettled(res, call.transport, call.encoding);
-    await assertOk(node, call, payload, `${label} (poll ${attempt}/${attempts})`);
+    await new Promise((r) => setTimeout(r, wait));
+    wait = Math.min(wait * 2, interval);
+
+    /**
+     * A MISSED POLL IS NOT A LOST JOB (2026-10-22). The job runs on the vendor's side; a status ask
+     * that cannot get through (the connection dropped, a gateway answered 502/503/504 while a
+     * container turned over) says nothing about the job. One such miss ended a parse that the
+     * vendor's own log shows finished sixteen seconds later. A miss is counted as an attempt and
+     * the wait goes on; only the attempts bound, or an answer that is an error, ends it.
+     */
+    let payload: any;
+    try {
+      const res = await sendRequest(node, statusCall, ctx, `${label} (poll ${attempt}/${attempts})`);
+      payload = await readSettled(res, call.transport, call.encoding);
+      await assertOk(node, call, payload, `${label} (poll ${attempt}/${attempts})`);
+    } catch (error: any) {
+      const text = String(error?.message ?? error);
+      if (attempt < attempts && /\b50[234]\b|fetch failed|ECONN|EAI_AGAIN|socket|timed out|aborted/i.test(text)) {
+        console.warn(`[manifests] ${label}: poll ${attempt}/${attempts} could not reach the job (${text.slice(0, 160)}); asking again`);
+        continue;
+      }
+      throw error;
+    }
 
     const status = typeof payload?.status === "string" ? payload.status : undefined;
     if (status !== lastStatus || attempt % heartbeat === 0)

package/vendor/base/src/manifests/runtime/tools/toolloop.ts

@@ -32,8 +32,11 @@ import { makeUsageCollector } from "../usage.js";
 export interface ToolBridge {
   /** Core tools from the provider's getSchema, as { name, description, parameters }. */
   discover(): Promise<any[]>;
-  /** Execute one call; returns the raw result content. */
-  call(name: string, args: any): Promise<string>;
+  /**
+   * Execute one call; returns the raw result content. `onStatus` hears what a called TASK is
+   * doing each time its status changes (docs/mcp/MCP_TASKS.md § 5, "what reaches the model").
+   */
+  call(name: string, args: any, hooks?: { onStatus?: (statusMessage: string) => void }): Promise<string>;
   /**
    * Absorb one tool reply: unlock + shell-open any apps it discovered, and hand back the
    * MODEL-FACING form of it plus any tools to register.
@@ -92,7 +95,7 @@ export function recordToolTrace(
    * on the same timeline but is not a tool the model chose, so it is told apart by a stated
    * kind rather than by the viewer sniffing its name.
    */
-  kind: "tool" | "skill" | "task" = "tool",
+  kind: "tool" | "skill" | "task" | "turn" = "tool",
 ): void {
   recordCall({ executionId: (ctx as any)?.scope?.executionId, parentNodeId: (ctx as any)?.scope?.nodeId, toolName, args, result, startTime, success, kind, who: node.type });
 }
@@ -111,7 +114,7 @@ export function recordCall(call: {
   result: unknown;
   startTime: number;
   success: boolean;
-  kind?: "tool" | "skill" | "task";
+  kind?: "tool" | "skill" | "task" | "turn";
   who: string;
 }): void {
   const { executionId, parentNodeId, toolName, args, result, startTime, success, kind = "tool" } = call;
@@ -245,8 +248,8 @@ export async function runToolLoop(
    *  written, or the held set would keep a skill the conversation has walked away from. */
   let skillsChanged = false;
 
-  // Token usage across ALL turns of this run — each turn is its own model call with its
-  // own usage block; the collector sums them and posts once when the loop settles.
+  // Token usage, posted after EACH turn (each turn is its own model call with its own usage
+  // block), so a run's spend is on record while it runs, and once more when the loop settles.
   const usage = makeUsageCollector(node, ctx);
 
   for (turn = 1; turn <= maxTurns; turn++) {
@@ -275,6 +278,9 @@ export async function runToolLoop(
     // would send each result twice — once as a message and once in a field the vendor ignores.
     if (results && !te.transcript) extra[te.resultsInto ?? "input"] = results;
 
+    // WHEN THE TURN STARTED, for its own row on the timeline (below): without it the gap between
+    // two rounds of tool calls could not be told apart into model time and everything else.
+    const turnStart = Date.now();
     const res = await sendRequest(node, withExtra(modelCall, extra), scoped, `${node.type} (turn ${turn})`);
 
     // Two readers of one stream: the events table decides what leaves the node, and the
@@ -291,6 +297,12 @@ export async function runToolLoop(
      * Chat Completions), and accumulated because it arrives a token at a time.
      */
     let spoken = "";
+    /**
+     * The assistant's OWN REASONING this turn, for a vendor that keeps it only when it is sent back
+     * (GLM's preserved thinking). Without it the model rebuilds its whole plan every turn. Read and
+     * accumulated exactly as `spoken` is; the manifest says where it arrives and where it goes back.
+     */
+    let thought = "";
     await readSse(res, modelCall.terminator, async (payload) => {
       await assertOk(node, modelCall, payload, `${node.type} (turn ${turn})`);
       usage.see(payload);
@@ -299,6 +311,10 @@ export async function runToolLoop(
         const piece = await evaluate(te.transcript.text, { response: payload });
         if (piece) spoken += String(piece);
       }
+      if (te.transcript?.thinking) {
+        const piece = await evaluate(te.transcript.thinking, { response: payload });
+        if (piece) thought += String(piece);
+      }
       // `match` is OPTIONAL. It selects by event TYPE, which only works for a vendor whose SSE
       // events carry one — the Responses API does. A Chat Completions chunk has no `type` at all, so
       // with no match declared every payload is considered and `when` does the filtering.
@@ -306,6 +322,7 @@ export async function runToolLoop(
       if (te.continuity && payload.type === te.continuity.match) chainPayload = payload;
     });
     if (chainPayload) chainId = String(await evaluate(te.continuity.from, { response: chainPayload }));
+    usage.save();
 
     // THE TURN IS OVER, SO NOTHING MORE IS COMING TO CARRY A THROTTLE OUT.
     //
@@ -314,13 +331,16 @@ export async function runToolLoop(
     // window — and if the model answered inside a single window, that is the whole answer
     // but its first token. It then surfaces on the next turn's first delta, which is after
     // any tool this turn called: the reader saw "I", then the rest eleven seconds later,
-    // and it read as the stream stopping for the tool (SAB, 2026-09-08).
+    // and it read as the stream stopping for the tool (a bank, 2026-09-08).
     //
     // Here rather than in the manifest, and by the LOOP rather than a timer: only the loop
     // knows where a turn ends, which is the same reason it owns counting them.
     emitter.flush();
 
     const calls = await readCalls(te, raw);
+    // EACH MODEL TURN ON THE TIMELINE, beside the calls it asked for: how long the model took,
+    // what it asked for and how much it wrote. Recorded once the turn has streamed in full.
+    recordCall({ executionId: (ctx as any)?.scope?.executionId, parentNodeId: (ctx as any)?.scope?.nodeId, toolName: `turn ${turn}`, args: { toolsOffered: live.length }, result: { asked: calls.map((c) => c.name), wroteChars: spoken.length }, startTime: turnStart, success: true, kind: "turn", who: node.type });
 
     // Answered rather than called. Done.
     if (!calls.length) break;
@@ -337,6 +357,8 @@ export async function runToolLoop(
     const absorbed: string[] = [];
     let stuck = false;
 
+    // Which calls run: every one before the first repeated too often, in the order asked.
+    const toRun: { call: (typeof calls)[number]; args: any }[] = [];
     for (const call of calls) {
       const signature = `${call.name}:${call.arguments}`;
       const count = (seen.get(signature) ?? 0) + 1;
@@ -346,25 +368,38 @@ export async function runToolLoop(
         stuck = true;
         break;
       }
-
       const args = JSON.parse(call.arguments || "{}");
       narrate({ kind: "toolCall", toolName: call.name, args });
+      toRun.push({ call, args });
+    }
 
-      let content: string;
-      /**
-       * THE TIMELINE BAR is the TOOL's to record, never the loop's (owner, 2026-10-01;
-       * packages/docs/nodes/mcp-services.md, "Who records a call"). Every tool records its
-       * own call wherever it runs (a node's method, a row's function, a platform tool), with
-       * `success` false on a failure, so a call reads the same from an Agent, a voice session
-       * or an outside host. The bar once vanished the day `openai` migrated, because it lived
-       * in each Agent family; it lives with the tool now.
-       */
-      try {
-        content = await bridge.call(call.name, args);
-      } catch (err: any) {
-        // A failed tool is information for the model, not a crash: it can try another.
-        content = JSON.stringify({ error: err?.message ?? String(err) });
-      }
+    /**
+     * THE CALLS OF ONE TURN RUN TOGETHER (UNO-190; docs/mcp/MCP_TASKS.md § 5, Orchestrated).
+     * A model that asks for several tools at once wants them side by side: twelve searches
+     * fanned out as tasks take as long as the slowest, not the sum. Everything after the call
+     * (recording, absorbing, skills in force, minted tools) still goes in the order asked.
+     *
+     * THE TIMELINE BAR is the TOOL's to record, never the loop's (owner, 2026-10-01;
+     * packages/docs/nodes/mcp-services.md, "Who records a call"). Every tool records its
+     * own call wherever it runs (a node's method, a row's function, a platform tool), with
+     * `success` false on a failure, so a call reads the same from an Agent, a voice session
+     * or an outside host. The bar once vanished the day `openai` migrated, because it lived
+     * in each Agent family; it lives with the tool now.
+     */
+    const contents = await Promise.all(
+      toRun.map(({ call, args }) =>
+        Promise.resolve()
+          // A TASK THAT RUNS FOR MINUTES SAYS WHAT IT IS DOING: each new status is narrated,
+          // so the caller (a person, a voice) hears progress before the result arrives.
+          .then(() => bridge.call(call.name, args, { onStatus: (status) => narrate({ kind: "taskStatus", toolName: call.name, args, status }) }))
+          // A failed tool is information for the model, not a crash: it can try another.
+          .catch((err: any) => JSON.stringify({ error: err?.message ?? String(err) })),
+      ),
+    );
+
+    for (let i = 0; i < toRun.length; i++) {
+      const { call, args } = toRun[i];
+      const content = contents[i];
       exchanges.push({ name: call.name, resultContent: content });
       // The RESULT, and only now that it exists. It is never in the HTTP stream: our loop
       // produced it, which is why it cannot be a `from: response` row. PARSED for the
@@ -432,7 +467,7 @@ export async function runToolLoop(
      * vendor's message shape — `te.result` produced them — so they go in as they are.
      */
     if (te.transcript) {
-      if (te.transcript.assistant) transcript.push(await evaluate(te.transcript.assistant, { calls, text: spoken }));
+      if (te.transcript.assistant) transcript.push(await evaluate(te.transcript.assistant, { calls, text: spoken, thinking: thought }));
       transcript.push(...results);
     }
   }