@unoverse-platform/studio 0.1.97 → 0.1.98

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

@@ -188,22 +188,58 @@ export function makeEmitter(node: ComposedNode, onEmit: (e: Emission) => void, b
       // on, and resetting first would clear the accumulator the row is about to read.
       resetTurn(match);
     },
+    /**
+     * Add to what EVERY row sees from now on, whatever it fires from.
+     *
+     * For state the caller accumulates over a run that no single event carries: a conversation
+     * held on a socket keeps what has been said so far, and a row that fires on one event (a
+     * hand-off) or at the end (the transcript) needs all of it.
+     */
+    extend(scope: Record<string, unknown>) {
+      Object.assign(base, scope);
+    },
     narrator: (line: string) => fire("narrator", { narrator: { line } }),
     tool: (call: { name: string; args: unknown; output: unknown }) => fire("tool", { call }),
 
     /**
-     * Send anything a throttle held back, then run the `complete` rows over the whole run.
-     * Flushing first matters: `complete` is usually defined over what was emitted.
+     * SEND WHAT THE THROTTLE IS HOLDING, without touching the accumulator.
+     *
+     * A throttled row keeps the newest value as `pending` and waits for a LATER DELTA to
+     * carry it out — there is no tick, by design (a timer here would fire against a run
+     * that may already be over). That is correct while tokens keep arriving and wrong the
+     * moment they stop: an answer that finishes inside one throttle window leaves every
+     * 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
+     * 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
+     * this, and the tool's duration was a coincidence.
+     *
+     * The CALLER decides when a turn ends, because only the loop knows: the manifest
+     * describes the wire, the loop counts the turns.
      */
-    async finish() {
+    flush() {
       for (let i = 0; i < rows.length; i++) {
         const s = state.get(i);
         if (s?.pending === undefined) continue;
         const emission = { ...destination(rows[i], s.to), value: s.pending };
         s.pending = undefined;
+        // The clock too, or the first delta of the next turn is held by a window that
+        // started before the flush and the same stall repeats one turn later.
+        s.lastAt = 0;
         emissions.push(emission);
         onEmit(emission);
       }
+    },
+
+    /**
+     * Send anything a throttle held back, then run the `complete` rows over the whole run.
+     * Flushing first matters: `complete` is usually defined over what was emitted.
+     */
+    async finish() {
+      this.flush();
       await fire("complete", { events: emissions.slice() });
       return emissions;
     },

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

@@ -0,0 +1,44 @@
+/**
+ * `concurrency` ON A CALL: at most this many of the call in flight at once, in this process,
+ * per credential (DECLARATIVE_NODES.md 8a). Earned against Hyperbrowser on 2026-09-09: the
+ * plan runs one browser session at a time, three product reads started their fetches in the
+ * same second, and two came back 429. The retry list already had 429, and it did not help:
+ * an exponential backoff of a second or so is nothing beside a twenty-second scrape.
+ *
+ * A vendor's limit is the node's fact, declared once on the call, so every caller gets it: a
+ * canvas workflow fanning out over ten URLs as much as an ingestion read. The caller says
+ * nothing. Absent means unbounded, which is what every call was before this existed.
+ *
+ * Process-wide by design: the manifest runtime is the one place every request goes through,
+ * and a per-process gate is exactly the shape of the limit (sessions the process holds open).
+ * Two engines on two hosts are two limits, and that is the vendor's problem to reject, which
+ * the retry then absorbs.
+ */
+interface Gate {
+  active: number;
+  waiting: Array<() => void>;
+}
+
+const gates = new Map<string, Gate>();
+
+/** Run `fn` when fewer than `limit` runs share `key`; otherwise wait in arrival order. */
+export async function withConcurrency<T>(key: string, limit: number, fn: () => Promise<T>): Promise<T> {
+  if (!(limit >= 1)) return fn();
+  let gate = gates.get(key);
+  if (!gate) { gate = { active: 0, waiting: [] }; gates.set(key, gate); }
+  if (gate.active >= limit) await new Promise<void>((resolve) => gate!.waiting.push(resolve));
+  gate.active += 1;
+  try {
+    return await fn();
+  } finally {
+    gate.active -= 1;
+    const next = gate.waiting.shift();
+    if (next) next();
+    else if (gate.active === 0) gates.delete(key);
+  }
+}
+
+/** How many runs share `key` right now, for a test or a status line. */
+export function inFlight(key: string): number {
+  return gates.get(key)?.active ?? 0;
+}

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

@@ -14,9 +14,11 @@ import { mintClientCredentials, 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";
+import { runRepeat } from "../loops/repeat.js";
 import { performLoop } from "../loops/loop.js";
 import { performDoc } from "../docstore/index.js";
 import { sendChunked } from "../loops/chunk.js";
+import { withConcurrency } from "./concurrency.js";
 
 /**
  * Build the HTTP request from a call. Auth schemes are executor capabilities.
@@ -235,7 +237,7 @@ 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.
  */
-async function fetchWithTimeout(url: string, init: any, timeoutMs: unknown, label: string): Promise<Response> {
+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);
 
@@ -592,7 +594,7 @@ export async function runCalls(
 
     // A CHUNKED call is many requests over one collection: { sent, batches, results, errors }.
     if (call.chunk) {
-      const written = await sendChunked(node, call, scoped, `${label}.${call.name}`);
+      const written = await gated(node, call, scoped, () => sendChunked(node, call, scoped, `${label}.${call.name}`));
       results[call.name] = written;
       last = written;
       continue;
@@ -600,7 +602,7 @@ export async function runCalls(
 
     // A PAGINATED call is many requests and one reply: { items, pages, truncated }.
     if (call.paginate) {
-      const walked = await fetchPaginated(node, call, scoped, `${label}.${call.name}`);
+      const walked = await gated(node, call, scoped, () => fetchPaginated(node, call, scoped, `${label}.${call.name}`));
       results[call.name] = walked;
       last = walked;
       continue;
@@ -609,12 +611,21 @@ export async function runCalls(
     // A POLLED call is a JOB: start it, then ask until it is done. The reply is the final
     // status payload, never the start receipt.
     if (call.poll) {
-      const finished = await fetchPolled(node, call, scoped, `${label}.${call.name}`);
+      const finished = await gated(node, call, scoped, () => fetchPolled(node, call, scoped, `${label}.${call.name}`));
       results[call.name] = finished;
       last = finished;
       continue;
     }
 
+    // A REPEATED call is turns of ordinary calls, each built from the one before, until a reply
+    // says done: { last, turns, stopped } (loops/repeat.ts). Each inner call is gated on its own.
+    if (call.repeat) {
+      const walked = await runRepeat(node, call, scoped, `${label}.${call.name}`, runCalls, store);
+      results[call.name] = walked;
+      last = walked;
+      continue;
+    }
+
     // SETTLING transports. `xml` settles exactly like json — one body, parsed once — so it
     // belongs here; only a STREAM is barred from a non-final position.
     if (call.transport !== "json" && call.transport !== "text" && call.transport !== "xml" && call.transport !== "headers" && call.transport !== "binary") {
@@ -625,9 +636,12 @@ export async function runCalls(
       );
     }
 
-    const res = await sendRequest(node, call, scoped, `${label}.${call.name}`);
-    const payload = await readSettled(res, call.transport, call.encoding);
-    await assertOk(node, call, payload, `${label}.${call.name}`);
+    const payload = await gated(node, call, scoped, async () => {
+      const res = await sendRequest(node, call, scoped, `${label}.${call.name}`);
+      const settled = await readSettled(res, call.transport, call.encoding);
+      await assertOk(node, call, settled, `${label}.${call.name}`);
+      return settled;
+    });
 
     results[call.name] = payload;
     last = payload;
@@ -635,3 +649,18 @@ export async function runCalls(
 
   return { results, last };
 }
+
+/**
+ * A call that declares `concurrency` runs through one gate per node, call and credential
+ * (concurrency.ts): the whole call, its polling included, because the vendor's session is
+ * held until the job ends. The credential is part of the key so two orgs' keys are two
+ * limits, as the vendor counts them. Used here for the lead calls and in channels/final.ts
+ * for the last one: a one-call node like HyperbrowserScrape only ever runs through final,
+ * which is where the first live run slipped past the gate (2026-09-09, two fetches at once).
+ */
+export async function gated<T>(node: ComposedNode, call: any, scoped: RunContext, fn: () => Promise<T>): Promise<T> {
+  const limit = Number(call.concurrency);
+  if (!(limit >= 1)) return fn();
+  const credential = call.credential?.value ? String(render(call.credential.value, scoped)) : "";
+  return withConcurrency(`${node.type}:${call.name}:${credential}`, limit, fn);
+}

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

@@ -25,7 +25,7 @@
  *     service.ts   an AGENT calls it: one method, one value handed straight back
  *   http/          building and sending. One fetch, one allowedHosts check
  *   auth/          the schemes, per scheme
- *   loops/         many requests, or many passes, for one node: paginate, poll, chunk, loop
+ *   loops/         many requests, or many passes, for one node: paginate, poll, chunk, repeat, loop
  *   duplex/        a socket that stays open. Two of them: the vendor's and the audio lane
  *   tools/         the HTTP tool exchange, by turns
  */
@@ -39,6 +39,7 @@ export { readSse, readSettled, assertOk } from "./http/response.js";
 export { makeStateStore, performState, type StateStore } from "./state.js";
 export { fetchPaginated } from "./loops/paginate.js";
 export { fetchPolled } from "./loops/poll.js";
+export { runRepeat, HARD_TURN_CAP } from "./loops/repeat.js";
 export { sendChunked } from "./loops/chunk.js";
 // Iteration bookkeeping for the LoopStart/LoopEnd pair. ONE capability rather than the seven raw
 // Redis commands the retired nodes reached for — see loops/loop.ts for why that distinction is
@@ -51,7 +52,7 @@ export { performDoc, MUTATING_DOC_OPS, docKeyFor } from "./docstore/index.js";
 export { runDuplexSession } from "./duplex/session.js";
 // The audio lane is its own module: session.ts owns the VENDOR socket, audioLane.ts owns the bytes
 // and the browser. Two sockets, two files.
-export { resamplePcm16, makeAudioBuffer, CLIENT_RATE, type AudioLane } from "./duplex/audioLane.js";
+export { resamplePcm16, mulawToPcm16, pcm16ToMulaw, makeAudioBuffer, CLIENT_RATE, type AudioLane } from "./duplex/audioLane.js";
 export { performApi, type RunResult } from "./channels/workflow.js";
 export { runFinal } from "./channels/final.js";
 export { performService } from "./channels/service.js";

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

@@ -0,0 +1,86 @@
+/**
+ * GO ROUND IN TURNS — the fourth loop (packages/docs/nodes/calls-that-loop.md `repeat`;
+ * DECLARATIVE_NODES.md, the capability table).
+ *
+ * `paginate` walks one API's pages, `chunk` sends one collection in slices, `poll` asks one
+ * question until the answer changes. None can say "ask different questions, each chosen by the
+ * last reply, until a reply says done", which is what walking a tree a branch at a time needs
+ * (OpenAISearchDetail). A manifest describes ONE turn as a short list of ordinary calls; the
+ * turning is computation, so it lives here.
+ *
+ * What a turn sees: every earlier call of the SAME turn as `calls.<name>`, as at the top level,
+ * and the turn before as `previous.<name>`. `previous` is null on the first turn, never absent:
+ * the expression sandbox refuses a name it does not know, so "is there a turn before?" must be
+ * a question it can answer (`previous ? … : …`).
+ *
+ * What stops it, borrowed from the agent node's own tool loop (toolExchange.yaml):
+ *   `until`             asked after every turn over that turn's calls; true ends the walk
+ *   `maxTurns`          the author's bound
+ *   `stuckAfterRepeats` a turn identical to the one before, that many times running, is stuck
+ *   HARD_TURN_CAP       the platform's bound, because the author's can be wrong
+ *
+ * The reply keeps EVERY turn, not only the last: the path taken is the lineage of the answer,
+ * and throwing it away would leave an answer nobody can check. Every turn is also drawn on the
+ * run's timeline with the same helper the tool loop uses, so the walk shows as it happens.
+ */
+import type { ComposedNode } from "../../compose.js";
+import type { RunContext } from "../context.js";
+import type { StateStore } from "../state.js";
+import { evaluate, render } from "../templating.js";
+import { recordToolTrace } from "../tools/toolloop.js";
+
+/** The platform's ceiling on turns, whatever the manifest says. */
+export const HARD_TURN_CAP = 20;
+
+/** How a turn's calls are run: the runtime's own call list, handed in so this file owns no request code. */
+export type RunList = (node: ComposedNode, calls: any[], ctx: RunContext, label: string, store?: StateStore) => Promise<{ results: Record<string, any>; last: any }>;
+
+/** A repeated call's reply: the last turn, every turn in order, and why it ended. */
+export interface Repeated {
+  last: Record<string, any>;
+  turns: Record<string, any>[];
+  stopped: "until" | "maxTurns" | "stuck";
+}
+
+/** A bound written as a number, a template (`{{ config.maxTurns }}`) or an expression. */
+async function numberOf(v: unknown, ctx: RunContext): Promise<number> {
+  if (typeof v === "number") return v;
+  if (typeof v !== "string") return NaN;
+  const out = v.trim().startsWith("return") ? await evaluate(v, ctx as unknown as Record<string, unknown>) : render(v, ctx);
+  return Number(out);
+}
+
+export async function runRepeat(node: ComposedNode, call: any, ctx: RunContext, label: string, run: RunList, store?: StateStore): Promise<Repeated> {
+  const r = call.repeat;
+  // NEVER A REPEAT INSIDE A TURN. Each is bounded, but nested they multiply (20 turns of 20),
+  // and a walk that needs a walk inside it is two nodes, not one. Lint refuses it too.
+  if (!Array.isArray(r?.calls) || !r.calls.length) throw new Error(`${label}: repeat has no calls, so a turn would do nothing`);
+  if (r.calls.some((c: any) => c?.repeat)) throw new Error(`${label}: a turn cannot itself repeat; nested repeats multiply their bounds`);
+  const asked = await numberOf(r.maxTurns, ctx);
+  const bound = Math.min(HARD_TURN_CAP, asked >= 1 ? Math.floor(asked) : HARD_TURN_CAP);
+  const stuckAt = Number(r.stuckAfterRepeats) >= 2 ? Math.floor(Number(r.stuckAfterRepeats)) : 0;
+
+  const turns: Record<string, any>[] = [];
+  let previous: Record<string, any> | null = null;
+  let same = 0;
+  let lastKey = "";
+  for (let n = 1; n <= bound; n++) {
+    const started = Date.now();
+    const turnCtx: RunContext = { ...ctx, previous };
+    const { results } = await run(node, r.calls, turnCtx, `${label} (turn ${n})`, store);
+    turns.push(results);
+    recordToolTrace(node, ctx, `${call.name} · turn ${n}`, { turn: n }, results, started, true);
+
+    if (await evaluate(r.until, { ...turnCtx, calls: results } as unknown as Record<string, unknown>)) return { last: results, turns, stopped: "until" };
+
+    // STUCK: the same turn again. `maxTurns` alone would let a walk that keeps choosing the
+    // same branch spend every turn it has doing so.
+    const key = JSON.stringify(results);
+    same = key === lastKey ? same + 1 : 1;
+    lastKey = key;
+    if (stuckAt && same >= stuckAt) return { last: results, turns, stopped: "stuck" };
+
+    previous = results;
+  }
+  return { last: turns[turns.length - 1] ?? {}, turns, stopped: "maxTurns" };
+}

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

@@ -47,6 +47,12 @@ export interface ToolBridge {
   ): Promise<{ content: string; minted: any[]; skills?: Array<{ name: string; title?: string; instructions: string; regionId?: string; regionName?: string | null; ms?: number }> }>;
   /** Does this exchange end the turn? Depends on which tools were WIRED. */
   endsTurn(calls: { name: string; resultContent: string }[]): boolean;
+  /**
+   * WHAT SORT OF STEP a call to this tool is on the timeline. The bridge minted the tool,
+   * so the bridge knows whether it came from a task row; the loop only relays the answer
+   * to the trace. Optional, because a core-tools-only bridge has nothing but tools.
+   */
+  kindOf?(toolName: string): "tool" | "task";
 }
 
 /**
@@ -92,7 +98,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" = "tool",
+  kind: "tool" | "skill" | "task" = "tool",
 ): void {
   const executionId = (ctx as any)?.scope?.executionId;
   const parentNodeId = (ctx as any)?.scope?.nodeId;
@@ -108,12 +114,20 @@ export function recordToolTrace(
    */
   const parsed = parseMaybeJson(result);
 
+  /**
+   * THE ARGUMENTS AS RUN. A tool whose own settings add to what the model sent (Spatial's
+   * always-on objects) says so in its result as `arguments`, and the trace shows those, so
+   * Arguments is what the call really ran with, never only what the model typed.
+   */
+  const ran = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as any).arguments : null;
+  const shown = ran && typeof ran === "object" && args && typeof args === "object" ? { ...(args as object), ...ran } : args;
+
   const endTime = Date.now();
   void saveMCPTraceToWorkflow({
     executionId,
     parentNodeId,
     toolName,
-    arguments: args,
+    arguments: shown,
     result: parsed,
     startTime,
     endTime,
@@ -280,6 +294,19 @@ export async function runToolLoop(
     });
     if (chainPayload) chainId = String(await evaluate(te.continuity.from, { response: chainPayload }));
 
+    // THE TURN IS OVER, SO NOTHING MORE IS COMING TO CARRY A THROTTLE OUT.
+    //
+    // A throttled row holds its newest value and waits for a LATER DELTA to send it. Within
+    // a turn that is right. At the end of one it strands whatever arrived in the last
+    // 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).
+    //
+    // 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);
 
     // Answered rather than called. Done.
@@ -334,7 +361,7 @@ export async function runToolLoop(
         ok = false;
         content = JSON.stringify({ error: err?.message ?? String(err) });
       }
-      recordToolTrace(node, ctx, call.name, args, content, startedAt, ok);
+      recordToolTrace(node, ctx, call.name, args, content, startedAt, ok, bridge.kindOf?.(call.name) ?? "tool");
       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

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

@@ -32,6 +32,12 @@ export function sniffUsage(payload: any): Record<string, unknown> | undefined {
 export interface UsageCollector {
   /** Look at one payload (streamed event or settled body); remember any usage block. */
   see(payload: any): void;
+  /**
+   * Record a figure the PLATFORM measured, replacing whatever the vendor reported under the same
+   * name. A voice call's `seconds` is this: the runtime opened and closed the call, so its clock is
+   * the length. A vendor that reports running totals (GPT-Live) would otherwise be summed.
+   */
+  set(field: string, value: number): void;
   /** Post the summed usage to the engine. No usage seen, or no execution scope → no-op. */
   save(): void;
 }
@@ -68,6 +74,10 @@ export function makeUsageCollector(node: ComposedNode, ctx: RunContext): UsageCo
       addInto(totals, u);
       model ??= payload?.response?.model ?? payload?.model ?? undefined;
     },
+    set(field: string, value: number) {
+      seen = true;
+      totals[field] = value;
+    },
     save() {
       if (!seen) return;
       const { workflowId, executionId, nodeId } = ctx.scope ?? {};

package/vendor/base/src/paths.ts

@@ -27,10 +27,11 @@ function findHome(): string {
 
   let dir = path.dirname(fileURLToPath(import.meta.url));
   for (;;) {
-    // The in-repo home. Checked for `nodes` as well as the folder itself, so a stray
-    // directory of the same name elsewhere cannot claim it.
+    // The in-repo home. Checked for `design` as well as the folder itself, so a stray
+    // directory of the same name elsewhere cannot claim it. (`nodes` was the marker until
+    // 2026-09-08, when nodes moved under design/marketplace with every other kind.)
     const candidate = path.join(dir, "apps/unoverse");
-    if (existsSync(path.join(candidate, "nodes"))) return candidate;
+    if (existsSync(path.join(candidate, "design"))) return candidate;
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;
@@ -41,7 +42,7 @@ function findHome(): string {
   // a path under cwd, and anything reading them will fail somewhere obvious.
   console.warn(
     "[unoverse:base] UNOVERSE_HOME is not set and no apps/unoverse was found above this package. " +
-      "Falling back to the working directory; set UNOVERSE_HOME to the folder holding nodes/, design/ and prompts/.",
+      "Falling back to the working directory; set UNOVERSE_HOME to the folder holding design/.",
   );
   return process.cwd();
 }
@@ -50,7 +51,7 @@ let HOME = findHome();
 
 /** Everything the runtime reads off disk, in one place. */
 export interface Paths {
-  /** Node manifests and node packages authored for this deployment. */
+  /** Node packages: the marketplace tier's nodes, under design/marketplace/nodes. */
   nodes: string;
   /** Design data: components, templates, styles. */
   design: string;
@@ -96,10 +97,17 @@ export function designDir(root: string): string {
 
 function derive(home: string): Paths {
   return {
-    nodes: path.join(home, "nodes"),
     design: designDir(home),
-    skills: path.join(home, "prompts/skills"),
-    promptBlocks: path.join(home, "prompts/blocks"),
+    // THE MARKETPLACE TIER, and it lives under design/ with every other kind.
+    //
+    // Skills and blocks were authored in a `prompts/` folder beside design/, left from
+    // before components, templates, atoms and styles took their marketplace home under
+    // `design/marketplace/`. Two roots for one tier is what let a surface read half of
+    // it and look right. There is one authoring root now: `design/`. Nodes were the
+    // last kind outside it, at `nodes/` beside design/, until 2026-09-08.
+    nodes: path.join(designDir(home), "marketplace/nodes"),
+    skills: path.join(designDir(home), "marketplace/skills"),
+    promptBlocks: path.join(designDir(home), "marketplace/blocks"),
     plugins: path.join(home, "plugins"),
     // DELIBERATELY under the home, not at the repo root.
     //

package/vendor/base/src/platform/audioManager.ts

@@ -89,6 +89,38 @@ class DistributedAudioManager implements AudioWebSocketManager {
   }
 }
 
+/**
+ * NAMED AUDIO LANES, beside the browser one.
+ *
+ * The browser manager above is fetched with no arguments, because for a long time it was the
+ * only lane. A phone lane has to PLACE A CALL, so it is built per run from that run's settings
+ * and credentials, which is why this is a factory rather than an instance.
+ *
+ * IT LIVES HERE, in base, for the reason the comment on `getAudioWebSocketManager` in
+ * executionContext.ts already gives: a node reaches the platform through two different context
+ * builders — the engine's plugin API in-process, and the remote one used by
+ * `POST /execute-stream` — and BOTH must arrive at the same lane. Registering it on only one of
+ * them is a voice node that finds its phone line locally and finds nothing remotely, which is
+ * exactly what happened (2026-09-20): no error, no audio, and a perfectly healthy conversation
+ * nobody could hear.
+ */
+let audioLaneFactory: ((spec: any) => any) | null = null;
+
+export function setAudioLaneFactory(factory: (spec: any) => any): void {
+  audioLaneFactory = factory;
+}
+
+/** A lane by name, built for this run. `null` when the platform has no such lane. */
+export function getAudioLane(spec: any): any {
+  if (!audioLaneFactory) return null;
+  try {
+    return audioLaneFactory(spec);
+  } catch (error: any) {
+    console.error(`[audio] lane "${spec?.lane}" could not be built: ${error?.message ?? error}`);
+    return null;
+  }
+}
+
 // Singleton instance
 let distributedAudioManager: DistributedAudioManager | null = null;
 

package/vendor/base/src/platform/executionContext.ts

@@ -11,6 +11,7 @@ import {
   deliverToNodeInWorkflow,
 } from "./serviceCalls.js";
 import { getRedisClient } from "./redis.js";
+import { getAudioLane } from "./audioManager.js";
 import { getDistributedAudioManager } from "./audioManager.js";
 
 /**
@@ -49,6 +50,12 @@ export function buildExecutionContext(nodeType: string, inputs: any, config: any
     abortSignal: context.abortSignal,
     logger: console,
     auth: context.auth,
+    /**
+     * A CANVAS TEST RUN. `debugMode` is the word that crosses the remote boundary
+     * (CallbackNodeActor's context whitelist); everything that withholds an effect with no
+     * inverse reads it. Dropping it here made a phone lane think every run was real.
+     */
+    debugMode: context.debugMode === true,
   };
 
   // Build API with callService that routes to workflow-service
@@ -97,6 +104,13 @@ export function buildExecutionContext(nodeType: string, inputs: any, config: any
      * Same accessor `pluginAPI.ts` uses, so both paths reach one manager rather than two.
      */
     getAudioWebSocketManager: () => getDistributedAudioManager(),
+    /**
+     * A lane BY NAME (DECLARATIVE_NODES.md §14, VOICE_STREAMING_GUIDE.md). Same registry the
+     * plugin API reads, for the same reason as the line above: a voice node runs through
+     * whichever of these two context builders its host chose, and a lane registered on only one
+     * of them is a phone that works in one place and silently does not in the other.
+     */
+    getAudioLane: (spec: any) => getAudioLane(spec),
     callService: async (method: string, params: any) => {
       return callServiceViaWorkflow(method, params, executionContext);
     },

package/vendor/base/src/platform/liveInput.ts

@@ -0,0 +1,52 @@
+/**
+ * LIVE INPUT: a value arriving on a node's `CONTINUE` input while that node is still running.
+ *
+ * A node that holds a conversation open (a duplex voice session) cannot be started again for each
+ * input the way a settle-once node can, because starting it again would open a second
+ * conversation. So the running node registers here, and the engine hands a changed `CONTINUE`
+ * input to it instead of dropping it.
+ *
+ * Keyed by `executionId:nodeId`, the two ids the engine and the running node both hold for the
+ * same run.
+ *
+ * ON globalThis, not a module-level Map. The engine and the node runtime share one process but
+ * may load this module under two specifiers (the package name, a relative path), and two copies
+ * of a Map would each be empty to the other: the engine would find no running node and drop the
+ * input exactly as before, with nothing to say why.
+ */
+
+/** Hand one input to the running node. Resolves false when the node could not take it. */
+export type LiveInputHandler = (handle: string, value: unknown) => Promise<boolean> | boolean;
+
+const REGISTRY = Symbol.for("unoverse.liveInput");
+
+function registry(): Map<string, LiveInputHandler> {
+  const g = globalThis as any;
+  return (g[REGISTRY] ??= new Map<string, LiveInputHandler>());
+}
+
+/** The key for one node in one run. Undefined when either id is missing: nothing to address. */
+export function liveInputKey(executionId?: string, nodeId?: string): string | undefined {
+  return executionId && nodeId ? `${executionId}:${nodeId}` : undefined;
+}
+
+/**
+ * Register the running node. Returns the unregister function.
+ *
+ * Unregistering removes only THIS handler, so a node that ended after a newer one registered
+ * under the same key cannot take the newer one with it.
+ */
+export function registerLiveInput(key: string, handler: LiveInputHandler): () => void {
+  const map = registry();
+  map.set(key, handler);
+  return () => {
+    if (map.get(key) === handler) map.delete(key);
+  };
+}
+
+/** Deliver to the running node. False when nothing is registered under the key. */
+export async function deliverLiveInput(key: string, handle: string, value: unknown): Promise<boolean> {
+  const handler = registry().get(key);
+  if (!handler) return false;
+  return (await handler(handle, value)) !== false;
+}

package/vendor/base/src/plugins/discovery.ts

@@ -39,7 +39,7 @@ function scanPluginDir(dir: string, scopes: string[]): string[] {
   return plugins;
 }
 
-/** Nodes that have been moved INTO Unoverse (apps/unoverse/nodes). */
+/** The marketplace tier's node packages (apps/unoverse/design/marketplace/nodes). */
 export function discoverNodesHome(): string[] {
   return scanPluginDir(NODES_HOME, ["@unoverse-platform/"]);
 }

package/vendor/base/src/template/SafeExpression.ts

@@ -521,6 +521,12 @@ const SUPPORTED = new Set([
   "BlockStatement", "CallExpression", "ConditionalExpression", "EmptyStatement",
   "ExpressionStatement", "Identifier", "IfStatement", "Literal", "LogicalExpression",
   "MemberExpression", "ObjectExpression", "Program", "Property", "ReturnStatement",
+  // `...x` in an object or an array. evalNode implements BOTH (ObjectExpression assigns the
+  // spread in, ArrayExpression pushes it), so leaving it out of this list made the static
+  // check refuse a form the interpreter runs — the exact inversion of what this list is for.
+  // It is only reached at run time by makeHelpers, so the three manifests that spread were
+  // never actually throwing; they were failing the guard that is supposed to mirror evalNode.
+  "SpreadElement",
   "TemplateLiteral", "TemplateElement", "UnaryExpression", "VariableDeclaration",
   "VariableDeclarator",
 ]);