@unoverse-platform/studio 0.1.96 → 0.1.98

package/vendor/base/src/lint/prompts/index.mjs

@@ -0,0 +1,198 @@
+/**
+ * The prompts linter: Agent skills and prompt blocks, as a LIBRARY. Rules in, findings out.
+ *
+ * A FOURTH SIBLING of ../design/, ../nodes/ and ../objects/ (2026-09-18). Until it existed
+ * nothing read a SKILL.md or a block before publish, and the run-time loaders drop a file
+ * they cannot parse with one console line and `null`. So a skill whose description held a
+ * bare colon (YAML reads `a: b: c` as a nested key) was published, installed, and absent
+ * from every list, and the first place anyone met the failure was an empty Studio screen.
+ * The author is the only person who can fix it, so the author is who this tells, at the
+ * line.
+ *
+ * What it holds a skill to is the same discoverability contract nodes are held to
+ * (https://docs.unoverse.ai/nodes/node-discoverability): a `whenToUse` that exists and
+ * carries selection signal, because a skill is found by ranking that text and nothing else.
+ *
+ * Callers: `unoverse lint` and `POST /publish` through items/publish lintForPublish; CI.
+ * Prints nothing, exits nothing, throws nothing for a lint failure.
+ *
+ * `options.overlay` maps an absolute path to text that STANDS IN for what is on disk, so an
+ * editor can lint what the developer has typed before it is saved.
+ */
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { join, resolve, relative, basename } from "node:path";
+import { createRequire } from "node:module";
+import { problems, reset, report } from "../context.mjs";
+
+const require_ = createRequire(import.meta.url);
+let YAML;
+try {
+  YAML = require_("yaml");
+} catch {
+  throw new Error("the prompts linter needs yaml (npm install -D yaml)");
+}
+
+const DISCOVERABILITY = "https://docs.unoverse.ai/nodes/node-discoverability";
+const KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+
+const isDir = (p) => existsSync(p) && statSync(p).isDirectory();
+const isRecord = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+
+/**
+ * Split a markdown file into frontmatter and body the way the run-time loaders do
+ * (gray-matter: a `---` line first, a `---` line closing). Returns
+ * `{ data, body, error, line }`: `data` is null when there is no block or it does not parse,
+ * and `line` is where in the FILE the parser stopped, so the finding lands on it.
+ */
+export function splitFrontmatter(text) {
+  const lines = text.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return { data: null, body: text, error: "no frontmatter block: the file must open with a --- line", line: 1 };
+  const close = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+  if (close < 0) return { data: null, body: "", error: "the frontmatter never closes: no second --- line", line: 1 };
+  const yamlText = lines.slice(1, close).join("\n");
+  const body = lines.slice(close + 1).join("\n");
+  try {
+    const data = YAML.parse(yamlText) ?? {};
+    if (!isRecord(data)) return { data: null, body, error: "the frontmatter is not a mapping of key: value lines", line: 2 };
+    return { data, body, error: null, line: 0 };
+  } catch (e) {
+    const at = e?.linePos?.[0]?.line ?? e?.linePos?.line;
+    const line = typeof at === "number" ? at + 1 : 2; // +1: the opening --- is line 1
+    return { data: null, body, error: e.message.split("\n")[0], line };
+  }
+}
+
+/**
+ * A YAML error most authors will hit once: a plain value with `: ` inside it. The parser's
+ * own sentence is right and unhelpful ("nested mappings are not allowed"); this one says
+ * what to do.
+ */
+function yamlHint(error, yamlLine) {
+  if (/nested mapping|implicit map keys|mapping pair|key node is missed/i.test(error) && /:\s/.test(yamlLine.replace(/^[^:]*:\s*/, "")))
+    return `${error}. A value holding a colon followed by a space must be quoted: description: "One thing: another"`;
+  return error;
+}
+
+function lintSkillFile(file, text, folderName, at) {
+  const { data, body, error, line } = splitFrontmatter(text);
+  if (!data) {
+    const src = text.split(/\r?\n/)[line - 1] ?? "";
+    report("error", at, `skill ${folderName}: ${yamlHint(error, src)}. The loaders skip a file they cannot parse, so this skill would not exist`, line);
+    return;
+  }
+  const name = typeof data.name === "string" ? data.name.trim() : "";
+  if (!name) report("error", at, `skill ${folderName}: name is missing; a SKILL.md without one does not load`);
+  else if (!KEBAB.test(name)) report("error", at, `skill ${folderName}: name "${name}" must be kebab-case: lowercase letters, digits and hyphens`);
+  else if (name !== folderName) report("error", at, `skill ${folderName}: name "${name}" differs from its folder; the folder is the lookup name and the two must agree`);
+
+  const description = typeof data.description === "string" ? data.description.trim() : "";
+  if (!description) report("error", at, `skill ${folderName}: description is missing; a SKILL.md without one does not load`);
+  else if (/\n/.test(description)) report("error", at, `skill ${folderName}: description must be one line; it is the listing subtitle`);
+  else if (description.length > 200) report("warn", at, `skill ${folderName}: description is ${description.length} characters; the listing subtitle reads best under 160`);
+
+  const w = typeof data.whenToUse === "string" ? data.whenToUse.trim() : "";
+  if (!w) report("error", at, `skill ${folderName}: whenToUse is missing. A skill is found by ranking this text; without it the skill cannot be discovered (${DISCOVERABILITY})`);
+  else {
+    if (description && w.toLowerCase() === description.toLowerCase()) report("error", at, `skill ${folderName}: whenToUse merely repeats description. It carries zero selection signal (${DISCOVERABILITY})`);
+    if (/^use this (skill|when)/i.test(w)) report("warn", at, `skill ${folderName}: whenToUse opens by restating itself. Lead with the OUTCOME in the user's own words (${DISCOVERABILITY})`);
+    if (/^(this is an?|a powerful|a comprehensive|an? (skill|guide) (for|that))/i.test(w)) report("warn", at, `skill ${folderName}: whenToUse opens with a label or marketing. Outcome first; it sinks the ranking (${DISCOVERABILITY})`);
+  }
+
+  if (data.triggers !== undefined && !(Array.isArray(data.triggers) && data.triggers.every((t) => typeof t === "string")))
+    report("error", at, `skill ${folderName}: triggers must be a list of phrases`);
+  if (data.title !== undefined && typeof data.title !== "string") report("error", at, `skill ${folderName}: title must be text`);
+  if (!data.title) report("hint", at, `skill ${folderName}: no title; the name "${name || folderName}" is what a person will see`);
+
+  if (!body.trim()) report("error", at, `skill ${folderName}: the body is empty; frontmatter alone is not a skill`);
+}
+
+function lintBlockFile(file, text, at) {
+  const id = basename(file, ".md");
+  const { data, body, error, line } = splitFrontmatter(text);
+  if (!data) {
+    const src = text.split(/\r?\n/)[line - 1] ?? "";
+    report("error", at, `block ${id}: ${yamlHint(error, src)}. The loaders skip a file they cannot parse, so this block would not exist`, line);
+    return;
+  }
+  if (!KEBAB.test(id)) report("error", at, `block ${id}: the filename must be kebab-case; it becomes the block's {{prompt.<camelCase>}} reference`);
+  if (typeof data.name !== "string" || !data.name.trim()) report("error", at, `block ${id}: name is missing`);
+  if (typeof data.description !== "string" || !data.description.trim()) report("error", at, `block ${id}: description is missing; it says what the block contributes to a prompt`);
+  if (data.tags !== undefined && !(Array.isArray(data.tags) && data.tags.every((t) => typeof t === "string"))) report("error", at, `block ${id}: tags must be a list of words`);
+  if (!body.trim()) report("error", at, `block ${id}: the body is empty`);
+  else if (/\{\{\s*prompt\./.test(body)) report("error", at, `block ${id}: references another block with {{prompt.…}}. A block stands alone; a node composes blocks, a block never does`);
+}
+
+/**
+ * Lint every skill and prompt block under `designRoot`: the marketplace tier and every org's.
+ * Returns `{ problems, skillCount, blockCount, designRoot }`.
+ */
+export function lintPrompts(designRoot, options = {}) {
+  const ROOT = resolve(designRoot);
+  reset(ROOT, "");
+  const overlay = {};
+  for (const [k, v] of Object.entries(options.overlay ?? {})) overlay[resolve(k)] = v;
+  const readText = (f) => (overlay[resolve(f)] === undefined ? readFileSync(f, "utf8") : overlay[resolve(f)]);
+  const present = (f) => existsSync(f) || overlay[resolve(f)] !== undefined;
+  const rel = (f) => (relative(process.cwd(), f).startsWith("..") ? f : relative(process.cwd(), f));
+
+  if (!isDir(ROOT)) {
+    report("error", ROOT, "no design/ folder here");
+    return { problems: [...problems], skillCount: 0, blockCount: 0, designRoot: ROOT };
+  }
+
+  // ── the tiers: the marketplace, every flat org folder, and the legacy orgs/ container ──
+  const tiers = [];
+  const marketplace = join(ROOT, "marketplace");
+  if (isDir(marketplace)) tiers.push({ org: undefined, dir: marketplace });
+  const orgDirs = (base) => readdirSync(base).filter((e) => !e.startsWith(".") && !e.startsWith("_") && e !== "marketplace" && e !== "orgs" && isDir(join(base, e)));
+  for (const e of orgDirs(ROOT)) tiers.push({ org: e, dir: join(ROOT, e) });
+  if (isDir(join(ROOT, "orgs"))) for (const e of orgDirs(join(ROOT, "orgs"))) tiers.push({ org: e, dir: join(ROOT, "orgs", e) });
+
+  let skillCount = 0;
+  let blockCount = 0;
+  for (const tier of tiers) {
+    const skills = join(tier.dir, "skills");
+    if (isDir(skills)) {
+      for (const e of readdirSync(skills, { withFileTypes: true })) {
+        if (e.name.startsWith(".")) continue;
+        const p = join(skills, e.name);
+        if (!e.isDirectory()) {
+          if (e.name.endsWith(".md")) report("warn", rel(p), `a skill is a folder holding SKILL.md, not a loose file; ${e.name} is not read`);
+          continue;
+        }
+        const file = join(p, "SKILL.md");
+        if (!present(file)) {
+          report("error", rel(file), `skill ${e.name}: the folder has no SKILL.md, so it is not a skill`);
+          continue;
+        }
+        skillCount++;
+        lintSkillFile(file, readText(file), e.name, rel(file));
+      }
+    }
+    const blocks = join(tier.dir, "blocks");
+    if (isDir(blocks)) {
+      const walk = (dir) => {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+          if (e.name.startsWith(".")) continue;
+          const p = join(dir, e.name);
+          if (e.isDirectory()) walk(p);
+          else if (e.name.endsWith(".md")) {
+            if (dir === blocks) report("warn", rel(p), `a block lives in a category folder (blocks/<category>/<name>.md); ${e.name} sits at the root and has no category`);
+            blockCount++;
+            lintBlockFile(p, readText(p), rel(p));
+          }
+        }
+      };
+      walk(blocks);
+    }
+  }
+
+  const rank = { error: 0, warn: 1, hint: 2 };
+  const sorted = [...problems].sort((a, b) => rank[a.level] - rank[b.level] || a.file.localeCompare(b.file));
+  return { problems: sorted, skillCount, blockCount, designRoot: ROOT };
+}
+
+/** True when anything would fail a build. Warnings and hints inform, errors stop. */
+export function hasErrors(result) {
+  return result.problems.some((p) => p.level === "error");
+}

package/vendor/base/src/manifests/compose.ts

@@ -13,7 +13,7 @@
  * scripts/lib/lint-nodes.mjs, which must run without the server (it ships in the
  * starter kit). Keep the two in step; the linter is the one developers see first.
  *
- * See docs/architecture/DECLARATIVE_NODES.md §5.
+ * See docs/architecture/authoring/DECLARATIVE_NODES.md §5.
  */
 import * as YAML from "yaml";
 import type { RawNode, RawPackage } from "./source.js";
@@ -33,6 +33,34 @@ const SECTIONS = ["interface", "config", "api", "test"] as const;
  * runnable node does. The second path imports this constant rather than restating it: two
  * copies of a control that decides who may run something is how they drift.
  */
+/**
+ * THE ONE HOLE IN THE WITHHOLDING RULE, and it is platform chrome so there is exactly one of it.
+ *
+ * NodeEffects.ts says there is no flag to override withholding, because an effect with no
+ * inverse is not something a test gets to do. That is right for a sent email or a charged card,
+ * and it makes such a node IMPOSSIBLE TO TRY: every way of running a workflow while building it
+ * is a test run, so the effect is traced and never performed, and the author cannot find out
+ * whether any of it works.
+ *
+ * So the hole exists, and these are its terms: OFF by default, injected only into nodes that
+ * actually emit, worded as what it does rather than as a mode, and the same field on every one
+ * of them — a per-vendor version of this would drift into five spellings of one idea.
+ *
+ * Injected beside the access chrome and for the same reason: it is a setting about the RUN, not
+ * about the job, so no author writes it.
+ */
+export const EMIT_CHROME = {
+  emitOnTestRun: {
+    type: "boolean",
+    title: "Perform on test runs",
+    description:
+      "This step acts outside the platform and cannot be undone, so test runs trace it rather " +
+      "than perform it. Enable only while testing this step, then switch it off.",
+    default: false,
+    "ui:widget": "toggle",
+  },
+} as const;
+
 export const RUN_AUTH_CHROME = {
   authRequired: {
     type: "boolean",
@@ -77,7 +105,13 @@ function deepMerge(base: any, over: any): any {
 
 export interface ComposedNode {
   type: string;
-  kind: "PromiseNode" | "CallbackNode";
+  /**
+   * `Attachment` is the one kind that is not about how a node RUNS, because it does not run
+   * (DECLARATIVE_NODES.md §14). It clips onto another node and overrides that node's config,
+   * so it has no api, no inputs and no outputs, and nothing downstream ever executes it. It
+   * composes like any other node because the canvas still has to find it in the catalog.
+   */
+  kind: "PromiseNode" | "CallbackNode" | "Attachment";
   packageName: string;
   /**
    * Hosts this node may call, from its package's `allowedHosts`. Empty means NONE: a
@@ -399,8 +433,10 @@ export function composeNode(raw: RawNode, pkg: RawPackage): ComposedNode {
       );
 
   if (!node.type) throw new ManifestError(`${where}: node.yaml has no type`);
-  if (node.kind !== "PromiseNode" && node.kind !== "CallbackNode")
-    throw new ManifestError(`${where}: node.yaml kind must be PromiseNode or CallbackNode, got ${JSON.stringify(node.kind)}`);
+  if (node.kind !== "PromiseNode" && node.kind !== "CallbackNode" && node.kind !== "Attachment")
+    throw new ManifestError(
+      `${where}: node.yaml kind must be PromiseNode, CallbackNode or Attachment, got ${JSON.stringify(node.kind)}`,
+    );
 
   const iface = parts.interface ?? {};
   const config = parts.config ?? {};
@@ -462,15 +498,41 @@ export function composeNode(raw: RawNode, pkg: RawPackage): ComposedNode {
   const authoredProps = { ...(authoredSchema.properties ?? {}) };
   delete authoredProps.authRequired;
   delete authoredProps.authRole;
-  const composedSchema = annotation
+  /**
+   * DOES THIS NODE REACH OUTSIDE? Its own capabilities say so, and for an ATTACHMENT what it
+   * contributes to its host says so: a phone line declares nothing about itself, it makes the
+   * voice node it clips onto emit (DECLARATIVE_NODES.md §14). Either way the switch belongs on
+   * the box a person opens, which is the box that declared it.
+   */
+  const emits = node.capabilities?.emitsExternally === true || iface.attaches?.capabilities?.emitsExternally === true;
+  const composedSchema = annotation && !emits
     ? authoredSchema
-    : { type: "object", ...authoredSchema, properties: { ...authoredProps, ...RUN_AUTH_CHROME } };
+    : {
+        type: "object",
+        ...authoredSchema,
+        properties: {
+          ...authoredProps,
+          ...(emits ? EMIT_CHROME : {}),
+          // An attachment never runs, so WHO may run it is a question it does not have.
+          ...(annotation ? {} : RUN_AUTH_CHROME),
+        },
+      };
   const authoredOrder: string[] | null = config["ui:order"] ?? null;
   const composedOrder =
-    annotation || !authoredOrder
+    !authoredOrder || (annotation && !emits)
       ? authoredOrder
-      : [...authoredOrder.filter((f) => f !== "authRequired" && f !== "authRole"), "authRequired", "authRole"];
-  const derived = streams || spawns || api?.toolExchange ? "CallbackNode" : "PromiseNode";
+      : [
+          ...authoredOrder.filter((f) => f !== "authRequired" && f !== "authRole" && f !== "emitOnTestRun"),
+          ...(emits ? ["emitOnTestRun"] : []),
+          ...(annotation ? [] : ["authRequired", "authRole"]),
+        ];
+  /**
+   * AN ATTACHMENT IS NOT DERIVED, because there is nothing to derive it from. Every signal the
+   * rule below reads — a streaming transport, a SPAWN port, a tool exchange — is a way of
+   * running, and an attachment declares none of them. Deriving would call it a PromiseNode and
+   * then refuse the manifest for saying Attachment, which is the declaration being right.
+   */
+  const derived = node.kind === "Attachment" ? "Attachment" : streams || spawns || api?.toolExchange ? "CallbackNode" : "PromiseNode";
   if (node.kind !== derived)
     throw new ManifestError(
       `${where}: declares kind "${node.kind}" but is a ${derived} (` +
@@ -492,6 +554,9 @@ export function composeNode(raw: RawNode, pkg: RawPackage): ComposedNode {
     definition: {
       type: node.type,
       name: node.name ?? node.type,
+      // What the CARD calls it, when the full name is too long for a box. Null falls back to
+      // `name` at the point of drawing, so an author who omits it changes nothing.
+      displayName: node.displayName ?? null,
       description: node.description ?? "",
       // The catalog ranker embeds this; losing it here would make the node invisible
       // to the building agent no matter how well it works.
@@ -513,6 +578,12 @@ export function composeNode(raw: RawNode, pkg: RawPackage): ComposedNode {
       logoUrl: node.logoUrl ?? pkgMeta.logoUrl ?? null,
       // How the canvas draws it. Absent means the ordinary node card.
       template: node.template ?? null,
+      // The card's menu entries (a person's faces on this node), carried verbatim to the canvas.
+      menu: Array.isArray(node.menu) ? node.menu : null,
+      // ATTACHMENTS (§14). What this one does to the node it clips onto: the host config
+      // fields it owns, and the credentials it contributes. Null for every ordinary node,
+      // which is also how the canvas tells the two apart without reading `kind`.
+      attaches: iface.attaches ?? null,
       visibility: node.visibility ?? "public",
       capabilities: node.capabilities ?? null,
       inputs: iface.inputs ?? [],
@@ -534,6 +605,6 @@ export function composeCredentials(pkg: RawPackage): Record<string, any>[] {
   return Object.entries(pkg.credentials).map(([file, body]) => {
     const doc = parse(body, `${pkg.name}/credentials/${file}`);
     if (!doc.name) throw new ManifestError(`${pkg.name}/credentials/${file}: no name`);
-    return { name: doc.name, displayName: doc.displayName ?? doc.name, description: doc.description ?? "", properties: doc.properties ?? [] };
+    return { name: doc.name, displayName: doc.displayName ?? doc.name, description: doc.description ?? "", category: doc.category ?? null, visibility: doc.visibility ?? "public", properties: doc.properties ?? [] };
   });
 }

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

@@ -6,7 +6,7 @@ import { contextFor } from "./context.js";
 import { sessionFor, stateStoreFor, audioLaneFor } from "./session.js";
 import { refireAfterDocMutation } from "./refire.js";
 import { toolBridgeFor } from "./toolBridge.js";
-import { hydrateMemory, ingestMemoryTurn } from "./memory.js";
+import { hydrateMemory, ingestMemoryTurn, sessionTurnRecorder } from "./memory.js";
 
 export class ManifestCallbackExecutor {
   logger: any = console;
@@ -66,8 +66,12 @@ export class ManifestCallbackExecutor {
     // The USER-MEMORY lane, before the run: when the node's config declares the toggle,
     // the person's context snapshot rides the prompt (memory.ts — the executor's job,
     // never a manifest's). No toggle, no prompt, headless → passes through untouched.
-    const hydratedConfig = await hydrateMemory(event.config, executionContext ?? this.executionContext);
+    // A SESSION is a run that holds a socket for the length of a call: the block rides the
+    // replayed history instead of a prompt, and turns are saved as they complete (below).
+    const session = Array.isArray(node.api?.run) && node.api.run.some((r: any) => r?.transport === "ws");
+    const hydratedConfig = await hydrateMemory(event.config, executionContext ?? this.executionContext, { session });
     const ctx = contextFor(node, event.inputs, hydratedConfig, executionContext ?? this.executionContext);
+    const turns = session ? sessionTurnRecorder(node.type, event.config, executionContext ?? this.executionContext) : null;
 
     let emitted = 0;
     const { outputs } = await performApi(
@@ -79,6 +83,7 @@ export class ManifestCallbackExecutor {
         // executor boundary, which is the only layer holding the execution context.
         if (!e.emit) return;
         emitted++;
+        turns?.see(e.emit, e.value);
         emit({ __outputs: { [e.emit]: e.value } });
       },
       node.api?.toolExchange ? await toolBridgeFor(executionContext ?? this.executionContext) : undefined,
@@ -93,14 +98,20 @@ export class ManifestCallbackExecutor {
 
     // The settled result: whatever `finalize` produced, plus any connector the stream
     // never touched. Emitting the last streamed value again would double it.
-    const streamed = new Set(node.api?.response?.events?.map((r: any) => r.emit) ?? []);
+    //
+    // The events table is `api.events`. This read `api.response.events`, a key no manifest has,
+    // so NOTHING counted as streamed and every connector was emitted a second time at the end:
+    // each downstream node fired twice on a final value, and a voice node's hand-off re-ran its
+    // backend at hang-up (observed live 2026-09-12).
+    const streamed = new Set((node.api?.events ?? []).map((r: any) => r.emit).filter(Boolean));
     const settled = Object.fromEntries(Object.entries(outputs).filter(([k]) => !streamed.has(k)));
     if (Object.keys(settled).length) emit({ __outputs: settled });
 
     // The turn complete — original input + final answer to user memory (fire-and-forget,
     // self-gating on the toggle; the ORIGINAL prompt, not the hydrated one, because the
     // memory block prepended above must not be re-ingested as something the user said).
-    await ingestMemoryTurn(node.type, event.config, executionContext ?? this.executionContext, outputs);
+    if (turns) await turns.flush();
+    else await ingestMemoryTurn(node.type, event.config, executionContext ?? this.executionContext, outputs);
 
     return { ...state, emitted, isComplete: true };
   }

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

@@ -30,6 +30,11 @@
 import type { ComposedNode } from "../compose.js";
 import { applyResolvers, emptyContext, type RunContext } from "../runtime/index.js";
 
+/** THE ENGINE'S ADDRESS, derived once from the port it listens on; the tool bridge reads the same one. */
+export function engineUrl(): string {
+  return `http://127.0.0.1:${process.env.ENGINE_PORT ?? process.env.WORKFLOW_SERVICE_PORT ?? 4101}`;
+}
+
 export function contextFor(node: ComposedNode, inputs: any, config: any, executionContext: any): RunContext {
   const user = executionContext?.auth?.user ?? {};
   return emptyContext({
@@ -59,9 +64,15 @@ export function contextFor(node: ComposedNode, inputs: any, config: any, executi
     scope: {
       userId: executionContext?.publishingContext?.userId ?? executionContext?.workflow?.variables?.userId,
       workflowId: executionContext?.workflowId ?? executionContext?.workflow?.id,
+      // THE WORLD THIS RUN WORKS IN (docs/unoverse/UNOVERSE_SPATIAL_ORG.md): named by the run,
+      // else the canvas's default. The spatial and ingest packages send it as the map's scope.
+      org: executionContext?.publishingContext?.org ?? executionContext?.workflow?.org,
       conversationId:
         executionContext?.publishingContext?.conversationId ?? executionContext?.workflow?.variables?.conversationId,
       chatId: executionContext?.publishingContext?.chatId ?? executionContext?.workflow?.variables?.chatId,
+      // A CANVAS TEST RUN: the engine's own debug mode for this run, sent with the node's context.
+      // A node keeps nothing between runs for one (docs/nodes/expressions.md, "The run context").
+      debug: executionContext?.debugMode === true,
       executionId: executionContext?.executionId,
       // Which INSTANCE on the canvas. The retired Code node fell back to the literal "code" when
       // this was missing, which meant two Code nodes minted the same universal id and the saved
@@ -104,7 +115,7 @@ export function contextFor(node: ComposedNode, inputs: any, config: any, executi
        * Same derivation as above, and the same reasoning: loopback because these listeners
        * are internal and never published, and derived so there is no dead variable to set.
        */
-      engineUrl: `http://127.0.0.1:${process.env.ENGINE_PORT ?? process.env.WORKFLOW_SERVICE_PORT ?? 4101}`,
+      engineUrl: engineUrl(),
     },
   });
 }

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

@@ -17,11 +17,28 @@
  * and ingest saves original input + final answer, never tool chatter.
  */
 
-/** Prepend the user's memory context to config.prompt when the toggle is on. */
-export async function hydrateMemory(config: any, executionContext: any): Promise<any> {
-  if (config?.enableUserMemory !== true || typeof config?.prompt !== "string") return config;
+/**
+ * Prepend the user's memory context when the toggle is on.
+ *
+ * A REQUEST node carries it on `config.prompt`: the user turn of every request.
+ *
+ * A SESSION node (a duplex socket: a voice call) has no prompt. It has a handshake, sent
+ * once, and a `conversationHistory` it replays as user messages before the call starts.
+ * The block goes in there, first, as one replayed user message: the same convention (the
+ * input side, never the system prompt) reached through the field the node already has, so
+ * no manifest changes to receive it and every vendor's replay carries it the same way.
+ */
+export async function hydrateMemory(config: any, executionContext: any, opts: { session?: boolean } = {}): Promise<any> {
+  if (config?.enableUserMemory !== true) return config;
   try {
     const harness: any = await import("../../agent-mcp/index.js");
+    if (opts.session) {
+      const block: string = await harness.fetchUserMemoryContext(config, executionContext, console);
+      if (!block) return config;
+      const history = Array.isArray(config.conversationHistory) ? config.conversationHistory : [];
+      return { ...config, conversationHistory: [{ role: "user", content: block }, ...history] };
+    }
+    if (typeof config?.prompt !== "string") return config;
     const prompt = await harness.hydratePromptWithUserMemory(config, executionContext, console, config.prompt);
     return prompt === config.prompt ? config : { ...config, prompt };
   } catch (e: any) {
@@ -60,3 +77,66 @@ export async function ingestMemoryTurn(
     console.log(`[manifests] memory ingest failed (non-blocking): ${e?.message ?? e}`);
   }
 }
+
+/**
+ * A SESSION'S TURNS, saved as they complete. A call is one run holding many turns, and the
+ * end-of-run ingest above would keep only the last exchange, at hang-up. Every voice node
+ * emits the two halves of a turn on the same two connectors: `userTranscript`, once per
+ * completed utterance, and `assistantTranscript`, accumulated as the model speaks and reset
+ * when its response ends.
+ *
+ * THE ORDER ON THE WIRE IS NOT THE ORDER OF THE CONVERSATION. The vendor starts the reply the
+ * moment the person stops speaking, and the transcript of what they said arrives a beat later,
+ * so the first words of an answer can precede the question they answer (observed live
+ * 2026-09-18: "How are you?" was saved against "I", and the greeting against nothing). So a
+ * turn is paired by what is in flight, not by arrival: a response that has just begun and has
+ * no question yet takes the next transcript as its question; a new response (the accumulated
+ * text no longer extends the last) closes the turn before it; and a transcript arriving while
+ * an older answer is still the pending one closes that turn and opens a fresh one. The final
+ * turn is flushed at the end.
+ *
+ * `null` when the toggle is off, so the emit path pays nothing.
+ */
+export function sessionTurnRecorder(
+  nodeType: string,
+  config: any,
+  executionContext: any,
+  now: () => number = Date.now,
+): { see(emit: string, value: unknown): void; flush(): Promise<void> } | null {
+  if (config?.enableUserMemory !== true) return null;
+  /** How long after a reply begins its question may still arrive. */
+  const LATE_QUESTION_MS = 4000;
+  let pending: { query: string; response: string; responseBegan: number } | null = null;
+  const save = async () => {
+    if (!pending || (!pending.query && !pending.response)) return;
+    const turn = pending;
+    pending = null;
+    try {
+      const harness: any = await import("../../agent-mcp/index.js");
+      harness.ingestConversationTurn(config, executionContext, { userMessage: turn.query, agentResponse: turn.response }, console, nodeType);
+    } catch (e: any) {
+      console.log(`[manifests] memory ingest failed (non-blocking): ${e?.message ?? e}`);
+    }
+  };
+  return {
+    see(emit, value) {
+      if (typeof value !== "string") return;
+      if (emit === "assistantTranscript") {
+        const extendsLast = !!pending && pending.response.length > 0 && value.startsWith(pending.response);
+        if (pending && pending.response && !extendsLast) {
+          // A new response began: the previous turn is complete.
+          void save();
+        }
+        if (!pending) pending = { query: "", response: "", responseBegan: now() };
+        if (!pending.response) pending.responseBegan = now();
+        pending.response = value;
+      } else if (emit === "userTranscript") {
+        const lateQuestion = !!pending && !pending.query && pending.response.length > 0 && now() - pending.responseBegan <= LATE_QUESTION_MS;
+        if (pending && !lateQuestion) void save();
+        if (lateQuestion) pending!.query = value;
+        else pending = { query: value, response: "", responseBegan: 0 };
+      }
+    },
+    flush: save,
+  };
+}

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

@@ -37,6 +37,56 @@ export function sessionFor(executionContext: any) {
  * for a headless run.
  */
 export function audioLaneFor(executionContext: any) {
+  /**
+   * WHICH LANE. `config.lane` is an ordinary config field on the voice node, usually written by
+   * an attachment (DECLARATIVE_NODES.md §14): clip a phone line on and it reads `twilio`.
+   *
+   * Absent or `browser` is the ordinary case and the default, so every voice node that existed
+   * before there were two lanes keeps the one it had.
+   */
+  /**
+   * FROM CONFIG, not from a field on the context.
+   *
+   * `lane` IS config — an ordinary field on the voice node, usually written there by an
+   * attachment (DECLARATIVE_NODES.md §14) — so config is where to read it, and reading it
+   * anywhere else was the bug. A voice node RUNS REMOTELY (`POST /execute-stream`), and that
+   * boundary carries `inputs`, `config` and a whitelisted `context`. A field added to the
+   * execution context simply does not cross it: the node ran, spoke the right words, and played
+   * them into a browser lane with nobody on it (observed live 2026-09-20).
+   *
+   * Config crosses because it has to. So read the lane from the thing that travels.
+   */
+  const lane = executionContext?.config?.lane ?? executionContext?.lane;
+  if (lane && lane !== "browser") {
+    const built = executionContext?.api?.getAudioLane?.({
+      lane,
+      conversationId: executionContext?.publishingContext?.conversationId ?? executionContext?.executionId,
+      /**
+       * EVERY attachment's own settings, keyed by node type, not just the one this lane came
+       * from. A phone number lives in here; the host's config holds only the fields an
+       * attachment locked.
+       *
+       * Handed over whole, because naming `attachments.TwilioLine` here would put one vendor's
+       * node type in the generic executor. A lane knows which attachment it belongs to; the
+       * thing building lanes in general does not.
+       */
+      attachments: executionContext?.config?.attachments ?? {},
+      credentials: executionContext?.credentials ?? {},
+      /**
+       * `debugMode` is the run's own word for a canvas test run and it DOES cross the remote
+       * boundary; `isTestRun` is the local execution context's name for the same thing. Either
+       * being true is a test run, because a lane that guessed wrong here would ring a real
+       * telephone once per build stage.
+       */
+      isTestRun: executionContext?.isTestRun === true || executionContext?.debugMode === true,
+    });
+    /**
+     * A NAMED LANE THAT COULD NOT BE BUILT DOES NOT FALL BACK TO THE BROWSER. Someone asked for
+     * a phone call; playing the audio into a browser tab instead would be a different thing
+     * happening silently. No lane is the honest answer, and the transcripts still arrive.
+     */
+    return built ?? null;
+  }
   return executionContext?.api?.getAudioWebSocketManager?.() ?? null;
 }