@unoverse-platform/studio 0.1.97 → 0.1.99

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

@@ -10,6 +10,29 @@
  * Returns undefined when nothing granted tools, and the node then runs as a single request.
  */
 import type { ToolBridge } from "../runtime/index.js";
+import { engineUrl } from "./context.js";
+
+/** The screen's verbs on an app with places (docs/unoverse/design/screen/UNOVERSE_SCREEN.md §3.3). */
+const SCREEN_VERBS = {
+  show: {
+    description:
+      "Set what the user sees. Give the ids of everything that should be on screen now: the cards your answer is about, as the search result lists them, and anything already on screen that should stay (the ON SCREEN line gives their ids). Whatever is on screen and not in your list closes, and an empty list clears the screen. If you do not call it, the screen stays as it is. Call it straight after the search, before reading details, so the user sees the cards at once. Do not list cards you will hand to a task, such as a comparison: a task you call opens by itself.",
+    parameters: {
+      type: "object",
+      properties: { ids: { type: "array", items: { type: "string" } } },
+      required: ["ids"],
+      additionalProperties: false,
+    },
+  },
+  read: {
+    description: "What the user is looking at: every place on screen and each interface in it, with its id, type, state and props.",
+    parameters: { type: "object", properties: {}, additionalProperties: false },
+  },
+  close: {
+    description: "Take one interface off the screen, by its id.",
+    parameters: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false },
+  },
+} as const;
 
 export async function toolBridgeFor(executionContext: any): Promise<ToolBridge | undefined> {
   const api = executionContext?.api;
@@ -25,8 +48,6 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
   }
   if (!schema?.methods) return undefined;
 
-  const core = new Set<string>(Object.keys(schema.methods));
-
   // Identity for a HELD app call: it renders on the caller's live session and elicits
   // from that human, so it needs the conversation, the turn, and the caller's token.
   // Using auth HERE is correct and different from exposing it to a manifest: this is the
@@ -62,6 +83,18 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
    */
   const discoveredApps = new Set<string>();
 
+  /**
+   * TOOLS MINTED FROM A TASK ROW, by minted name. A call to one of these is a task step on
+   * the execution timeline, not a bare tool call; `kindOf` answers from this set.
+   */
+  const taskTools = new Set<string>();
+  /**
+   * TOOLS WHOSE CALL HANDS THE TURN OFF: a workflow-bound app fired through the service
+   * lane (`workflow@trigger`, fire-and-forget). Only these can end the loop; a component
+   * app, a workflow task (held, its result comes back) or a platform tool never does.
+   */
+  const handoffTools = new Set<string>();
+
   /**
    * THE GUEST'S OWN WORDS, from the search that is about to unlock a page.
    *
@@ -79,19 +112,36 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
   const stringify = (r: unknown): string => (typeof r === "string" ? r : JSON.stringify(r));
 
   /**
-   * PAGES ALREADY OPEN IN THIS CONVERSATION (the latch's other half, 2026-09-02).
+   * PAGES ALREADY OPEN IN THIS CONVERSATION (2026-09-02).
    *
-   * A follow-up send addressed at an open page starts a FRESH agent, and the page's tool
+   * A follow-up send while a page is open starts a FRESH agent, and the page's tool
    * was minted in an earlier run and died with it — so the agent could only chat at the
-   * page (observed live: three consecutive turns of clarifying questions at a latched
+   * page (observed live: three consecutive turns of clarifying questions at an open
    * page it had no tool to edit). At bridge build the open pages are read from the
    * server's open-apps resource and their tools minted exactly like an unlock mint,
-   * minus the shell-open — the page is already on screen. The same resource read RE-ARMS
-   * read-first server-side, so this new agent's first authored call is answered with the
-   * current page rather than rendered blind. Fail-soft: any error means nothing
-   * pre-minted, which is exactly the old behaviour.
+   * minus the shell-open — the page is already on screen. Fail-soft: any error means
+   * nothing pre-minted, which is exactly the old behaviour.
    */
   const preMinted: any[] = [];
+  /**
+   * THE SCREEN VERBS (docs/unoverse/design/screen/UNOVERSE_SCREEN.md §3.3): every agent gets them.
+   * A search returns data and draws nothing; the verbs are the door itself: show by id, read
+   * every place, close by id. Plain platform tools on /mcp, called with the session identity.
+   */
+  for (const verb of ["show", "read", "close"] as const) {
+    // Underscore, not dot: model providers restrict tool names to [a-zA-Z0-9_-].
+    const name = `screen_${verb}`;
+    appInvokers.set(name, async (input) => {
+      const { client, close } = await harness.connectPlatformMcp({ accessToken: identity.accessToken });
+      try {
+        const r = (await client.callTool({ name, arguments: { ...((input ?? {}) as Record<string, unknown>), userId: identity.userId, conversationId: identity.conversationId, chatId: identity.chatId } })) as { content?: Array<{ type: string; text?: string }> };
+        return r.content?.find((c) => c.type === "text")?.text ?? "";
+      } finally {
+        await close();
+      }
+    });
+    preMinted.push({ name, ...SCREEN_VERBS[verb] });
+  }
   if (identity.conversationId) {
     try {
       const { client, close } = await harness.connectPlatformMcp({ accessToken: identity.accessToken });
@@ -118,9 +168,10 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
           discoveredApps.add(mcp.component);
           preMinted.push({
             ...def,
-            description:
-              `${def.description}\n\nTHIS PAGE IS ALREADY OPEN in this conversation — the user is looking at it now. ` +
-              `To act on their message, call this tool with the parts to change; your first call is answered with the current page so you read before editing.`,
+            // WHAT IS ON SCREEN, said where the decision is made: a message about the page itself
+            // is answered by updating it. "About it" is narrow on purpose: read loosely, the model
+            // rebuilt a comparison for "what is the best card for travel" (observed live).
+            description: `${def.description}\n\nON SCREEN NOW: this page is open and the user is looking at it. A message about the page itself updates it through this tool.`,
           });
           console.log(`[manifests] open page re-minted for this turn: ${def.name}`);
         }
@@ -190,45 +241,27 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
           const def = await harness.resolveToolDefNative(mcp, { accessToken: identity.accessToken });
           const invoke = harness.componentAppInvoker(mcp, identity);
           appInvokers.set(def.name, invoke);
+          if (mcp.task) taskTools.add(def.name);
 
           /**
-           * THE PAGE FILLS BEFORE THE WRITER GETS THE PEN (owner ruling 2026-09-01 night).
-           *
-           * The shell-open renders the page skeleton and runs the page's OWN fill — its
-           * searches, the director's picks, the tiles (§9e). It used to be fire-and-forget
-           * while the tool was minted immediately, so the model composed captions for a page
-           * it had never seen; a read-first bounce tried to repair that and depended on the
-           * model re-sending, which it sometimes simply did not (observed 15:45: bounce, no
-           * resend, ghost headings shipped). So the ORDER is now physical: the shell call is
-           * AWAITED, and only then is the tool minted — with the page's chosen places in the
-           * tool's own description. The writer cannot write blind, and nothing needs bouncing.
-           *
-           * The guest loses nothing: the skeleton and the tiles render during this await; only
-           * the model's captions start those few seconds later. A failed shell mints the tool
-           * with its plain description — a page that arrives the old way, never a dead turn.
-           *
-           * `__draftRefs` carries the UNLOCKING SEARCH'S ranked row ids (the server drafts
-           * ref-only parts from them); the execution ids trace the page's searches into the
-           * run's own timeline.
+           * A TASK OPENS WHEN THE LLM CALLS IT (UNOVERSE_RENDER_PIPELINE §4, locked
+           * 2026-09-06). This used to open the shell at MINT — every app a search unlocked
+           * was rendered before the model had read the results (observed 2026-09-07: two
+           * surfaces opened at once, neither asked for). Tasks are asked: the unlock mints the
+           * tool and nothing more. What the shell-open used to carry — the unlocking search's
+           * ranked rows for drafting, the guest's ask for the page's own searches, the run's
+           * ids for tracing — rides the model's CALL instead, beneath its own arguments.
            */
           const draftRefs = harness.rankedRowIds(resultContent);
-          let chosenNote = "";
-          try {
-            const opened = await invoke({
-              __draftRefs: draftRefs,
-              ...(lastAsk ? { __ask: lastAsk } : {}),
-              ...(executionContext?.workflowId ? { __workflowId: executionContext.workflowId } : {}),
-              ...(executionContext?.executionId ? { __executionId: executionContext.executionId } : {}),
-              ...(executionContext?.nodeId ? { __nodeId: executionContext.nodeId } : {}),
-            });
-            const msg = typeof (opened as { message?: unknown })?.message === "string" ? (opened as { message: string }).message : "";
-            const chosen = msg.match(/THE PAGE'S CONTENT IS ALREADY CHOSEN — [^\n]*?never a different plan\./)?.[0];
-            if (chosen) chosenNote = `\n\n${chosen}`;
-            console.log(`[manifests] shell opened: ${def.name}${draftRefs.length ? ` (${draftRefs.length} draft refs)` : ""}${lastAsk ? ` ask="${lastAsk}"` : ""}${chosen ? " — chosen places ride the tool description" : ""}`);
-          } catch (e: any) {
-            console.log(`[manifests] shell open failed for ${def.name} — ${e?.message ?? e}`);
-          }
-          minted.push({ name: def.name, description: `${def.description}${chosenNote}`, parameters: def.parameters });
+          const ride = {
+            __draftRefs: draftRefs,
+            ...(lastAsk ? { __ask: lastAsk } : {}),
+            ...(executionContext?.workflowId ? { __workflowId: executionContext.workflowId } : {}),
+            ...(executionContext?.executionId ? { __executionId: executionContext.executionId } : {}),
+            ...(executionContext?.nodeId ? { __nodeId: executionContext.nodeId } : {}),
+          };
+          appInvokers.set(def.name, (input: unknown) => invoke({ ...ride, ...((input ?? {}) as Record<string, unknown>) }));
+          minted.push({ name: def.name, description: def.description, parameters: def.parameters, ...(def.outputSchema ? { outputSchema: def.outputSchema } : {}) });
         },
       );
 
@@ -246,9 +279,37 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
         for (const mcp of harness.parseDiscoveredMCPs([{ name: toolName, resultContent }]))
           if (!harness.isBindinglessComponentApp(mcp)) {
             const def = harness.toolDefFromDiscoveredMCP(mcp);
-            minted.push({ name: def.name, description: def.description, parameters: def.parameters });
+            // A WORKFLOW TASK (2026-09-06) is called NATIVELY: the held call runs the Agent
+            // and returns its result. Registered by the minted name, like a component app.
+            if (harness.isWorkflowTask(mcp)) appInvokers.set(def.name, harness.workflowTaskInvoker(mcp, identity));
+            else if (mcp.workflowId) {
+              // 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 —
+              // 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, identity));
+              handoffTools.add(def.name);
+            }
+            if (mcp.task) taskTools.add(def.name);
+            minted.push({ name: def.name, description: def.description, parameters: def.parameters, ...(def.outputSchema ? { outputSchema: def.outputSchema } : {}) });
           }
 
+      /**
+       * THE FOUND ROWS' OWN FUNCTIONS (docs/unoverse/data/spatial/objects-in-spatial.md, "Found
+       * objects' functions as tools", 2026-09-16). The engine names, once per name, every public
+       * function the result's objects declare; each becomes a tool here, called on a row by its
+       * id through the engine's one function door. Spatial's node keeps only its two searches:
+       * a document's getDetail, a fund's documents, a skill's readSkill all arrive this way, the
+       * moment a row of theirs is found. Deduped downstream by tool name, like the apps above.
+       */
+      for (const fn of harness.parseOfferedFunctions(toolName, resultContent)) {
+        const def = harness.objectFunctionToolDef(fn);
+        appInvokers.set(def.name, harness.objectFunctionInvoker(fn, engineUrl()));
+        minted.push({ name: def.name, description: def.description, parameters: def.parameters });
+      }
+
       /**
        * SKILLS IN FORCE, lifted before the lean drops them. Handed back beside `minted`
        * because they are the same kind of fact: something the reply UNLOCKED that the loop
@@ -260,7 +321,11 @@ export async function toolBridgeFor(executionContext: any): Promise<ToolBridge |
     },
 
     endsTurn(calls) {
-      return harness.isTurnEndingHandoff(calls, core);
+      return harness.isTurnEndingHandoff(calls, handoffTools);
+    },
+
+    kindOf(toolName) {
+      return taskTools.has(toolName) ? "task" : "tool";
     },
   };
 }

package/vendor/base/src/manifests/runtime/auth/aws.ts

@@ -123,6 +123,19 @@ export async function signAwsRequest(
   return signed.headers as Record<string, string>;
 }
 
+/**
+ * ONE LINK PER HOUR, NOT PER CALL (2026-09-12: a document's picture reopened in a panel was
+ * downloaded again on every open, because every open minted a new link and a browser caches
+ * by URL). A link of two hours or more is signed as of the start of the current hour, so every
+ * ask inside that hour gets the same URL and the browser keeps what it already loaded. Such a
+ * link lives `expiresIn` from that hour's start: up to an hour less than asked, never more. A
+ * shorter link is signed at its own second, so it is never cut by a large share of its life.
+ */
+const HOUR_MS = 3_600_000;
+export function signingDateOf(expiresIn: number, now = Date.now()): Date {
+  return expiresIn * 1000 >= 2 * HOUR_MS ? new Date(Math.floor(now / HOUR_MS) * HOUR_MS) : new Date(now);
+}
+
 /**
  * A PRESIGNED URL: authority to fetch one object, handed to someone who has no credentials.
  *
@@ -174,7 +187,7 @@ export async function presignAwsUrl(
       // as a dependency for one header.
       headers: { host: parsed.host, "x-amz-content-sha256": "UNSIGNED-PAYLOAD" },
     }),
-    { expiresIn },
+    { expiresIn, signingDate: signingDateOf(expiresIn) },
   );
 
   const out = new URL(`${signed.protocol}//${signed.hostname}${signed.path}`);

package/vendor/base/src/manifests/runtime/channels/final.ts

@@ -21,13 +21,14 @@
 import type { ComposedNode } from "../../compose.js";
 import type { RunContext } from "../context.js";
 import { evaluate, render } from "../templating.js";
-import { sendRequest, buildRequest, performPresign } from "../http/request.js";
+import { sendRequest, buildRequest, performPresign, gated, runCalls } from "../http/request.js";
 import { readSse, readSettled, assertOk } from "../http/response.js";
 import { runDuplexSession } from "../duplex/session.js";
 import type { AudioLane } from "../duplex/audioLane.js";
 import { performState, type StateStore } from "../state.js";
 import { fetchPaginated } from "../loops/paginate.js";
 import { fetchPolled } from "../loops/poll.js";
+import { runRepeat } from "../loops/repeat.js";
 import { sendChunked } from "../loops/chunk.js";
 import { performLoop } from "../loops/loop.js";
 import { performDoc } from "../docstore/index.js";
@@ -82,13 +83,17 @@ export async function runFinal(
   if (call.presign) return settle(await performPresign(node, call, ctx));
 
   // Chunked: many requests over one collection, one summary reply.
-  if (call.chunk) return settle(await sendChunked(node, call, ctx, node.type));
+  if (call.chunk) return settle(await gated(node, call, ctx, () => sendChunked(node, call, ctx, node.type)));
 
   // Paginated: many requests, one accumulated reply, so the events table sees the whole set.
-  if (call.paginate) return settle(await fetchPaginated(node, call, ctx, node.type));
+  if (call.paginate) return settle(await gated(node, call, ctx, () => fetchPaginated(node, call, ctx, node.type)));
 
   // Polled: a job, started and waited on, settling as the final status payload.
-  if (call.poll) return settle(await fetchPolled(node, call, ctx, node.type));
+  if (call.poll) return settle(await gated(node, call, ctx, () => fetchPolled(node, call, ctx, node.type)));
+
+  // Repeated: turns of ordinary calls, each built from the one before, until a reply says done.
+  // Settles on { last, turns, stopped }, so the events table sees the answer and its path.
+  if (call.repeat) return settle(await runRepeat(node, call, ctx, node.type, runCalls, store));
 
   // DUPLEX, and it must come BEFORE sendRequest, because a socket handshake is not an HTTP
   // request and issuing one would open a second connection to the vendor and pay for it.
@@ -112,6 +117,9 @@ export async function runFinal(
     // no tokens at all. `usage.save()` sits BEFORE the throw: a call that ended badly still
     // burned what it spoke.
     const usage = makeUsageCollector(node, ctx);
+    // THE CALL'S LENGTH, timed here because this is what opens and closes it. Per-minute vendors
+    // (GPT-Live, Grok) bill on it; per-token ones get it shown beside their tokens.
+    const opened = Date.now();
     const result = await runDuplexSession({
       node,
       call,
@@ -129,43 +137,47 @@ export async function runFinal(
         void emitter.narrator(message);
       },
     });
+    usage.set("seconds", Math.round((Date.now() - opened) / 100) / 10);
     usage.save();
     if (result.reason === "error") throw new Error(`${node.type}: duplex session failed: ${result.error}`);
     return 200;
   }
 
-  const res = await sendRequest(node, call, ctx, node.type);
-  const transport = call.transport;
-
-  if (transport === "json" || transport === "text") {
-    const payload = await readSettled(res, transport, call.encoding);
-    await assertOk(node, call, payload, node.type);
-    // Token usage: a settled vendor body carries it inline (Chat Completions puts it
-    // top-level). One payload, so see + save in one breath.
-    const usage = makeUsageCollector(node, ctx);
-    usage.see(payload);
-    usage.save();
-    // Named BEFORE emitting, so a row reading calls.<name> sees it.
-    //
-    // Settling only. A streaming call has no single reply to name: it is a sequence, and
-    // each event arrives as `response`. Inventing a value for `calls.<name>` there would be
-    // a guess about which event counted.
-    (base.calls as Record<string, unknown>)[call.name] = payload;
-    // No `match`: a settled body is one event, so every `from: response` row fires over it.
-    await emitter.response(payload);
-    return res.status;
-  }
+  // The settling or streaming request, under the call's concurrency gate when it declares one.
+  return gated(node, call, ctx, async () => {
+    const res = await sendRequest(node, call, ctx, node.type);
+    const transport = call.transport;
 
-  if (transport === "sse") {
-    const usage = makeUsageCollector(node, ctx);
-    await readSse(res, call.terminator, async (payload) => {
+    if (transport === "json" || transport === "text") {
+      const payload = await readSettled(res, transport, call.encoding);
       await assertOk(node, call, payload, node.type);
+      // Token usage: a settled vendor body carries it inline (Chat Completions puts it
+      // top-level). One payload, so see + save in one breath.
+      const usage = makeUsageCollector(node, ctx);
       usage.see(payload);
-      await emitter.response(payload, payload.type);
-    });
-    usage.save();
-    return res.status;
-  }
+      usage.save();
+      // Named BEFORE emitting, so a row reading calls.<name> sees it.
+      //
+      // Settling only. A streaming call has no single reply to name: it is a sequence, and
+      // each event arrives as `response`. Inventing a value for `calls.<name>` there would be
+      // a guess about which event counted.
+      (base.calls as Record<string, unknown>)[call.name] = payload;
+      // No `match`: a settled body is one event, so every `from: response` row fires over it.
+      await emitter.response(payload);
+      return res.status;
+    }
+
+    if (transport === "sse") {
+      const usage = makeUsageCollector(node, ctx);
+      await readSse(res, call.terminator, async (payload) => {
+        await assertOk(node, call, payload, node.type);
+        usage.see(payload);
+        await emitter.response(payload, payload.type);
+      });
+      usage.save();
+      return res.status;
+    }
 
-  throw new Error(`transport "${transport}" is declared in the schema but not implemented in the executor`);
+    throw new Error(`transport "${transport}" is declared in the schema but not implemented in the executor`);
+  });
 }

package/vendor/base/src/manifests/runtime/channels/service.ts

@@ -9,9 +9,9 @@
 import type { ComposedNode } from "../../compose.js";
 import type { RunContext } from "../context.js";
 import { evaluate } from "../templating.js";
-import { runCalls } from "../http/request.js";
+import { runCalls, resolveBody } from "../http/request.js";
 import type { StateStore } from "../state.js";
-import { rowComponentsFromResults, renderRowComponents, screenLine } from "../../../agent-mcp/rowComponents.js";
+import { rowComponentsFromResults, placesOn, placesLine, rememberRows } from "../../../agent-mcp/rowComponents.js";
 import { withHelpers } from "../helpers.js";
 
 /**
@@ -47,6 +47,16 @@ export async function performService(
   return withHelpers(node, () => serviceMethod(node, method, params, ctx, store, session));
 }
 
+/**
+ * A METHOD'S REPLY: one `return` expression, or an object whose values may be expressions, the
+ * way a call's `body` already is (docs/unoverse/data/spatial/objects-in-spatial.md). What forced
+ * it: `getSchema` returns a large fixed schema by `$ref`, and the Spatial node adds one value to
+ * it computed per run (the objects the agent may turn on). A literal value is returned as written.
+ */
+function reply(returns: unknown, scope: Record<string, unknown>): Promise<unknown> {
+  return returns && typeof returns === "object" ? resolveBody(returns, scope as unknown as RunContext) : evaluate(returns, scope);
+}
+
 async function serviceMethod(
   node: ComposedNode,
   method: string,
@@ -88,7 +98,7 @@ async function serviceMethod(
    * manifest declaring this stays pure everywhere it is not wanted, with no flag to juggle.
    */
   if (spec.renderComponents) {
-    const rows = await evaluate(spec.renderComponents, { response: last, calls: results, params, config: ctx.config });
+    const rows = await evaluate(spec.renderComponents, { response: last, calls: results, params });
     const found = rowComponentsFromResults(rows);
     // SAY WHAT HAPPENED, always: this lane no-ops on no component rows or no live session,
     // and silence must not read as success. `renderRowComponents` logs its own settles.
@@ -99,40 +109,28 @@ async function serviceMethod(
       accessToken: session?.accessToken,
     };
     const log = (m: string) => console.log(`[manifests] ${node.type}: ${m}`);
-    if (found.length) {
-      if (!session?.userId) {
-        console.log(`[manifests] ${node.type}: ${found.length} row component(s) not rendered — no live session on this run`);
-      }
-      const outcomes = renderRowComponents(found, sessionCtx, log);
-      /**
-       * THE SEARCH MIRRORS TOO (MCP_APP_PROTOCOL §0.1, ruled 2026-09-05). When the delivery
-       * holds a component that takes input (a shell), the model must answer the SCREEN,
-       * not the rows: it wait for the delivery's verdict — instant here, the ladder at the
-       * door leaves one candidate and the rules brain answers at once — and the result
-       * carries a `screen` line saying what is on screen and what was not shown.
-       * Card-only deliveries stay fire-and-forget, as fast as ever.
-       */
-      if (found.some((i) => i.shell)) {
-        const screen = screenLine(await outcomes);
-        const result = await evaluate(spec.returns, { response: last, calls: results, params, config: ctx.config, user: ctx.user });
-        return screen && result && typeof result === "object" && !Array.isArray(result) ? { ...(result as Record<string, unknown>), screen } : result;
-      }
-    } else {
-      const n = Array.isArray(rows) ? rows.length : 0;
-      console.log(`[manifests] ${node.type}: no row components in ${n} row(s)`);
-      // The empty delivery is announced (§12e mechanical spent rule): this search
-      // ran and surfaced nothing, and the standing set's fate hangs on that fact.
-      void renderRowComponents(found, sessionCtx, log);
-    }
+    /**
+     * AN APP WITH PLACES (docs/unoverse/design/screen/UNOVERSE_SCREEN.md §3.1): a search returns
+     * data and draws nothing. Its cards are remembered for the turn and listed for the model by
+     * id; the model shows the ones its answer is about with screen_show.
+     */
+    if (session?.conversationId && session?.userId) rememberRows(session.conversationId, session.chatId ?? session.conversationId, found);
+    else if (found.length) console.log(`[manifests] ${node.type}: ${found.length} row component(s) not remembered — no live session on this run`);
+    const result = await reply(spec.returns, { response: last, calls: results, params, user: ctx.user });
+    const task = result && typeof result === "object" && (result as any).task && typeof (result as any).task === "object" ? (result as any).task : null;
+    const screen = placesLine(session?.conversationId, placesOn(session?.conversationId), found, task);
+    return result && typeof result === "object" && !Array.isArray(result) ? { ...(result as Record<string, unknown>), screen } : result;
   }
 
-  // `params`, `config` and `user` are in scope so a method can shape its result from what
-  // it was asked for and who asked, not only from what came back.
-  return evaluate(spec.returns, {
+  // `params` and `user` are in scope so a method can shape its result from what it was
+  // asked for and who asked, not only from what came back. `config` is NOT (owner ruling
+  // 2026-09-20, docs/unoverse/mail/README.md "who sees what"): a method's reply goes to a
+  // MODEL, and a box's settings are the author's, never the model's. The calls still read
+  // config to build their requests; that happens here, server-side, and never leaves.
+  return reply(spec.returns, {
     response: last,
     calls: results,
     params,
-    config: ctx.config,
     user: ctx.user,
   });
 }

package/vendor/base/src/manifests/runtime/channels/workflow.ts

@@ -23,7 +23,7 @@ import { runToolLoop, type ToolBridge } from "../tools/toolloop.js";
 import { runFinal } from "./final.js";
 import { withHelpers } from "../helpers.js";
 import { clientTransport } from "../../../platform/clientTransport.js";
-import { rowComponentsFromResults, renderRowComponents } from "../../../agent-mcp/rowComponents.js";
+import { rowComponentsFromResults, rememberRows } from "../../../agent-mcp/rowComponents.js";
 import type { CallerSession } from "./service.js";
 
 export interface RunResult {
@@ -272,16 +272,11 @@ async function renderRunComponents(
     accessToken: session?.accessToken,
   };
   const found = rowComponentsFromResults(rows);
-  if (found.length) {
-    if (!session?.userId) log(`${found.length} row component(s) not rendered — no live session on this run`);
-    renderRowComponents(found, sessionCtx, log);
-  } else {
-    const n = Array.isArray(rows) ? rows.length : 0;
-    log(`no row components in ${n} row(s)`);
-    // The empty delivery is announced (§12e mechanical spent rule): this search
-    // ran and surfaced nothing, and the standing set's fate hangs on that fact.
-    renderRowComponents(found, sessionCtx, log);
-  }
+  // A SEARCH RETURNS DATA AND DRAWS NOTHING (docs/unoverse/design/screen/UNOVERSE_SCREEN.md §3.1):
+  // its cards are remembered for the turn; the model shows the ones its answer is about with
+  // screen_show.
+  if (session?.conversationId && session?.userId) rememberRows(session.conversationId, session.chatId ?? session.conversationId, found);
+  log(found.length ? `${found.length} row component(s) remembered for screen_show` : `no row components in ${Array.isArray(rows) ? rows.length : 0} row(s)`);
 }
 
 /**

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

@@ -29,6 +29,12 @@ export interface RunContext {
    * phrase for two different things.
    */
   calls: Record<string, any>;
+  /**
+   * THE TURN BEFORE THIS ONE, inside a `repeat` (loops/repeat.ts): that turn's calls by name.
+   * Null on a repeat's first turn, so an expression can ask whether there is one; absent
+   * everywhere outside a repeat.
+   */
+  previous?: Record<string, any> | null;
   /**
    * The CALLER'S DISCONNECT, when the node runs over a stream. Set from the request's
    * own signal; a turn loop checks it between turns and stops. Absent for a node that
@@ -85,7 +91,7 @@ export interface RunContext {
    * its own address. Loopback, because :4106 is the ungated internal listener and is published to
    * 127.0.0.1 only.
    */
-  scope: { userId?: string; workflowId?: string; org?: string; conversationId?: string; chatId?: string; executionId?: string; nodeId?: string; platformUrl?: string; engineUrl?: string };
+  scope: { userId?: string; workflowId?: string; org?: string; conversationId?: string; chatId?: string; debug?: boolean; executionId?: string; nodeId?: string; platformUrl?: string; engineUrl?: string };
   /**
    * THE CONVERSATION SO FAR, for a tool loop against a vendor with no chain id.
    *
@@ -132,13 +138,19 @@ export const RESOLVERS: Record<string, (value: any, node: ComposedNode) => any>
   modelTier(value: any, node: ComposedNode) {
     const field = node.definition.configSchema?.properties?.model;
     const options: string[] = field?.enum ?? [];
-    if (!value || options.includes(value)) return value || options[0];
+    // THE LARGEST MODEL IS NEVER TAKEN BY ACCIDENT (owner, 2026-09-12: "we should never have
+    // been using Sol in the first place"; a pipeline that named no model ran every call on the
+    // frontier tier, first in the list, for days). A node that names no model runs on its own
+    // declared default; the large tier only ever runs because someone chose it.
+    const fallback: string | undefined = typeof field?.default === "string" && options.includes(field.default) ? field.default : options[1] ?? options[0];
+    if (!value) return fallback;
+    if (options.includes(value)) return value;
     const m = String(value).toLowerCase();
-    // Tier words cover both families the packages ship: GPT (luna/terra) and Claude
-    // (haiku/sonnet). Anything unrecognised lands on large, the safe over-provision.
-    const tier = /luna|mini|small|nano|haiku/.test(m) ? 0 : /terra|balanced|medium|sonnet/.test(m) ? 1 : 2;
+    // Tier words cover both families the packages ship: GPT (luna/terra/sol) and Claude
+    // (haiku/sonnet/opus). A retired id keeps its tier; one naming no tier takes the default.
+    const tier = /luna|mini|small|nano|haiku/.test(m) ? 0 : /terra|balanced|medium|sonnet/.test(m) ? 1 : /sol|large|frontier|opus/.test(m) ? 2 : -1;
     // Options are listed large first, so index from the end for small.
-    const picked = [options[options.length - 1], options[1], options[0]][tier] ?? options[0];
+    const picked = tier < 0 ? fallback : ([options[options.length - 1], options[1], options[0]][tier] ?? fallback);
     console.warn(`[manifests] model "${value}" is no longer available — using "${picked}". Update this node.`);
     return picked;
   },