@unoverse-platform/studio 0.1.90 → 0.1.92

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

@@ -0,0 +1,65 @@
+/**
+ * THE WAY BACK TO A CONNECTED PERSON. Injected, never imported.
+ *
+ * A running node sometimes has to reach the browser that is waiting on it: a realtime node
+ * streams audio down, and a component node pushes a rendered piece of interface. Both are
+ * genuinely needed, and neither belongs in this package.
+ *
+ * The reason is not taste. The audio path is a uWebSockets socket and the component path is
+ * an MCP stream with its own session registry: both are the SERVER's connections, owned by
+ * the process that accepted them. This package reached across and imported them directly,
+ * which meant it could not be installed anywhere else — the imports pointed at a folder that
+ * only exists in that one repo.
+ *
+ * So it is inverted. This file says WHAT the runtime needs, in four functions; the server
+ * hands in HOW at boot, exactly as it already does for Redis (`setRedisClient`).
+ *
+ * DEFAULTS ARE NO-OPS, deliberately. A box that runs nodes with nobody watching (a cron, a
+ * queue worker, a test) has no client to push to, and that is a normal state rather than a
+ * failure. A node that emits audio into a run nobody is watching should carry on, not throw.
+ */
+
+export interface ClientTransport {
+  /**
+   * Push a message to a client over the data plane. Rendered components travel this way.
+   * Keyed by userId AND conversationId, because one person may have several open.
+   * Returns false when nobody is listening.
+   */
+  pushToClient(userId: string, conversationId: string, message: Record<string, any>): boolean;
+
+  /** Stream audio bytes down to a connected client. False when nobody is listening. */
+  sendAudioToClient(conversationId: string, audioData: Buffer | ArrayBuffer): boolean;
+
+  /** Tell a client the audio session changed state (started, ended, interrupted). */
+  sendAudioStateToClient(conversationId: string, state: string, metadata?: Record<string, unknown>): boolean;
+
+  /** Register the handler for audio arriving FROM a client. */
+  setAudioDataHandler(handler: (conversationId: string, audioData: ArrayBuffer) => Promise<void>): void;
+
+  /** Register the handler for audio control messages from a client. */
+  setAudioControlHandler(handler: (conversationId: string, message: Record<string, unknown>) => Promise<void>): void;
+}
+
+/**
+ * `false` from the send functions, not `true`: with no transport there IS no listener, and
+ * saying otherwise would have a caller believe audio reached someone.
+ */
+const NONE: ClientTransport = {
+  pushToClient: () => false,
+  sendAudioToClient: () => false,
+  sendAudioStateToClient: () => false,
+  setAudioDataHandler: () => {},
+  setAudioControlHandler: () => {},
+};
+
+let transport: ClientTransport = NONE;
+
+/** Called once by the host at boot, with its own websocket and data-plane implementations. */
+export function setClientTransport(impl: Partial<ClientTransport>): void {
+  transport = { ...NONE, ...impl };
+}
+
+/** The transport in force. Never null, so no caller has to guard. */
+export function clientTransport(): ClientTransport {
+  return transport;
+}

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

@@ -0,0 +1,157 @@
+/**
+ * Execution Context Builder
+ * Builds the execution context for node execution in node-service
+ */
+
+import { clientTransport } from "./clientTransport.js";
+import {
+  callServiceViaWorkflow,
+  saveTokenUsageToWorkflow,
+  saveMCPTraceToWorkflow,
+  deliverToNodeInWorkflow,
+} from "./serviceCalls.js";
+import { getRedisClient } from "./redis.js";
+import { getDistributedAudioManager } from "./audioManager.js";
+
+/**
+ * Build execution context for a node
+ */
+export function buildExecutionContext(nodeType: string, inputs: any, config: any, context: any) {
+  const credentials = context.credentials || {};
+  const publishingContext = context.publishingContext;
+  const serviceNodeId = context.serviceNodeId;
+
+  // Extract workflow variables - they come from context.variables (passed from CallbackNodeActor)
+  const workflowVariables = context.variables || {};
+
+  // Build execution context first so we can reference it in callService
+  const executionContext: any = {
+    nodeId: context.nodeId || `node-service-${Date.now()}`,
+    executionId: context.executionId || `exec-${Date.now()}`,
+    workflowId: context.workflowId || "node-service",
+    nodeType,
+    config,
+    inputs,
+    credentials,
+    serviceNodeId,
+    // Preserve workflow definition for service calls (node lookups) AND add variables for MCP discovery
+    workflow: context.workflow
+      ? { ...context.workflow, variables: workflowVariables }
+      : {
+          id: context.workflowId || "node-service",
+          runId: context.executionId || `exec-${Date.now()}`,
+          variables: workflowVariables,
+        },
+    publishingContext,
+    activeLoop: context.activeLoop,
+    // The caller's disconnect, when the node runs over a stream (routeExecuteStream). A
+    // turn loop checks it between turns so a reaped run stops spending model calls.
+    abortSignal: context.abortSignal,
+    logger: console,
+    auth: context.auth,
+  };
+
+  // Build API with callService that routes to workflow-service
+  executionContext.api = {
+    gravityPublish: async () => {},
+    createLogger: (name: string) => {
+      const log = (level: string, ...args: any[]) => {
+        const msg = args.map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ");
+        console.log(JSON.stringify({ level, nodeType: name, msg, service: "node-service" }));
+      };
+      return {
+        info: (...args: any[]) => log("info", ...args),
+        error: (...args: any[]) => log("error", ...args),
+        debug: (...args: any[]) => log("debug", ...args),
+        warn: (...args: any[]) => log("warn", ...args),
+      };
+    },
+    getNodeCredentials: async (ctx: any, credentialName: string) => {
+      return credentials[credentialName] || {};
+    },
+    saveTokenUsage: saveTokenUsageToWorkflow,
+    saveMCPTrace: saveMCPTraceToWorkflow,
+    /**
+     * THE `send:` BRIDGE, and it belongs on THIS api for the reason the audio-lane note below
+     * spells out: a manifest node has only what is on `executionContext.api`. `pluginAPI.ts`
+     * exposing it is not enough — that is the api a PLUGIN receives at setup, and LoopEnd runs
+     * here, in the node host, reached remotely by the engine.
+     *
+     * Same crossing as `saveTokenUsage` above: the work happens in the workflow service, so the
+     * call goes over the same door. It THROWS on failure rather than logging, because a dropped
+     * delivery is a loop that stops after one pass and reports success.
+     */
+    deliverToNode: async (executionId: string, nodeId: string, handle: string, value: unknown, signal?: string) =>
+      deliverToNodeInWorkflow({ executionId, nodeId, handle, value, signal }),
+    getRedisClient,
+    /**
+     * THE AUDIO LANE, and its absence here was a total, silent failure of every voice node.
+     *
+     * A live voice node registers its microphone handler and sends the model's speech through this
+     * handle. It was missing from THIS api — the one the runtime builds per execution — while
+     * `pluginAPI.ts` exposed it on the api a PLUGIN receives at setup. A code node reached the lane
+     * through plugin-base's platform singleton and never noticed; a manifest node has only what is
+     * on `executionContext.api`, so it got `undefined`, took the no-lane path, and ran a perfectly
+     * healthy conversation that nobody could hear or speak to. No error, in either direction.
+     *
+     * Same accessor `pluginAPI.ts` uses, so both paths reach one manager rather than two.
+     */
+    getAudioWebSocketManager: () => getDistributedAudioManager(),
+    callService: async (method: string, params: any) => {
+      return callServiceViaWorkflow(method, params, executionContext);
+    },
+    getWebSocketManager: () => {
+      if (!publishingContext) {
+        return null;
+      }
+      return {
+        get: (userId: string, conversationId: string) => ({
+          mountedComponents: new Set<string>(),
+          currentTemplate: null as string | null,
+          send: (data: string) => {
+            const message = JSON.parse(data);
+            // §5/§5a data plane — components/data + template state go ONLY to the native MCP
+            // SSE stream. The legacy WS is AUDIO-ONLY now (the SDK reads components from MCP).
+            clientTransport().pushToClient(userId, conversationId, message);
+          },
+        }),
+      };
+    },
+    publishStreamingUpdate: (streamConfig: { componentType: string; props: Record<string, any> }) => {
+      if (!publishingContext) {
+        return;
+      }
+      const { chatId, conversationId, userId } = publishingContext;
+      const nodeId = context.nodeId;
+      const workflowId = context.workflowId;
+
+      const componentKey = `${chatId}_${nodeId}`;
+      const event = {
+        id: `stream_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        timestamp: new Date().toISOString(),
+        type: "COMPONENT_INIT",
+        nodeId,
+        chatId,
+        conversationId,
+        userId,
+        providerId: "streaming",
+        component: {
+          type: streamConfig.componentType,
+          // §4a: address the component on the Unoverse definition server, not a legacy
+          // `/components/<x>.js` bundle. The SDK resolves it by type over MCP.
+          componentUrl: `unoverse://components/${streamConfig.componentType}`,
+          props: streamConfig.props,
+        },
+        metadata: {
+          workflowId,
+          componentKey,
+          streaming: true,
+        },
+      };
+
+      clientTransport().pushToClient(userId, conversationId, event);
+    },
+  };
+
+  return executionContext;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Platform Module
+ * Re-exports all platform functionality for node-service
+ */
+
+export { getDistributedAudioManager } from "./audioManager.js";
+export { callServiceViaWorkflow, saveTokenUsageToWorkflow } from "./serviceCalls.js";
+export { buildExecutionContext } from "./executionContext.js";
+export { createNodeServiceAPI } from "./pluginAPI.js";
+export { setRedisClient, getRedisClient } from "./redis.js";

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

@@ -0,0 +1,146 @@
+/**
+ * Plugin API Factory
+ * Creates the minimal Plugin API for node-service plugin registration
+ */
+
+import { PromiseNode, CallbackNode, NodeInputType } from "../pluginBase.js";
+import { getNodeRegistry, registerCredentialType } from "../registry.js";
+import { getDistributedAudioManager } from "./audioManager.js";
+import {
+  saveTokenUsageToWorkflow,
+  saveMCPTraceToWorkflow,
+  emitNodeOutputToWorkflow,
+  deliverToNodeInWorkflow,
+} from "./serviceCalls.js";
+import { getRedisClient } from "./redis.js";
+import { boot } from "../boot.js";
+
+/**
+ * Create a minimal Plugin API for node-service
+ * Collects registered nodes without needing full platform dependencies
+ */
+export function createNodeServiceAPI() {
+  const nodeRegistry = getNodeRegistry();
+
+  return {
+    registerNode(node: any) {
+      const def = node.definition;
+      const executor = node.executor;
+
+      // Determine execution mode by checking if executor has initializeState
+      let executionMode: "single" | "generator" = "single";
+      try {
+        const proto = executor.prototype;
+        if (proto && typeof proto.initializeState === "function") {
+          executionMode = "generator";
+        }
+      } catch (e) {}
+
+      nodeRegistry.set(def.type, {
+        type: def.type,
+        name: def.name,
+        description: def.description || "",
+        // whenToUse is the field the catalog ranker (CatalogService) embeds for
+        // semantic node search. Omitting it here drops it for EVERY node at
+        // registration — Redis stores "", ranking falls back to description, and
+        // discovery degrades platform-wide. It must survive into the registry.
+        whenToUse: def.whenToUse || "",
+        category: def.category || "general",
+        version: def.version || "1.0.0",
+        configSchema: def.configSchema || {},
+        // The authored settings-form order. Must survive into the registry for the same
+        // reason whenToUse must: dropped here means dropped for every node platform-wide,
+        // and the canvas falls back to schema declaration order.
+        "ui:order": def["ui:order"] || null,
+        inputs: def.inputs || [],
+        outputs: def.outputs || [],
+        color: def.color || "#6366f1",
+        logoUrl: def.logoUrl || null,
+        template: def.template || null,
+        nodeSize: def.nodeSize || { width: 200, height: 100 },
+        isService: def.isService || false,
+        serviceConnectors: def.serviceConnectors || null,
+        componentTemplate: def.componentTemplate || null,
+        // Per-component render-URL map for the generic `Component` node (org-aware).
+        // The Canvas resolves an instance's URL from config.component against this.
+        componentUrls: def.componentUrls || null,
+        credentials: def.credentials || [],
+        testData: def.testData || null,
+        // Author-declared capabilities (e.g. cacheable) must survive into the
+        // registry so the engine's memoization gate can read them — without this
+        // the field is lost at load and isCacheable() is always false.
+        capabilities: def.capabilities || null,
+        executor,
+        executionMode,
+      });
+
+      boot.node(def.type);
+    },
+    registerService: () => {},
+    registerCredential: (credentialType: any) => {
+      registerCredentialType(credentialType);
+    },
+    registerComponentPath: () => {},
+    createLogger: () => console,
+    getConfig: () => ({}),
+    saveTokenUsage: saveTokenUsageToWorkflow,
+    saveMCPTrace: saveMCPTraceToWorkflow,
+    getNodeCredentials: async (context: any, credentialName: string) => {
+      const cred = context?.credentials?.[credentialName];
+      if (!cred) {
+        console.error(
+          `[node-service] Credential ${credentialName} not found. Available: ${Object.keys(
+            context?.credentials || {},
+          ).join(", ")}`,
+        );
+      }
+      return cred || null;
+    },
+    callService: async () => ({}),
+    getRedisClient,
+    gravityPublish: async () => {},
+    getAudioWebSocketManager: () => getDistributedAudioManager(),
+    getWebSocketManager: () => null,
+    executeNodeWithRouting: async (
+      executeNode: (inputs: any, config: any, context: any) => Promise<any>,
+      params: any,
+      config: any,
+      context: any,
+    ) => {
+      // Run the node locally (package hybrid nodes run in node-service).
+      const result = await executeNode(params, config, context);
+
+      // Bridge to workflow-service so the xstate actor emits NODE_OUTPUT
+      // and downstream nodes fire. Same contract as the in-process
+      // executeNodeWithRouting in workflow-service.
+      const executionId = context?.executionId;
+      const nodeId = context?.nodeId;
+      if (executionId && nodeId) {
+        await emitNodeOutputToWorkflow({ executionId, nodeId, output: result });
+      } else {
+        console.warn(
+          "[node-service] executeNodeWithRouting: missing executionId or nodeId — NODE_OUTPUT not emitted",
+        );
+      }
+
+      return result;
+    },
+    /**
+     * The `send:` row's bridge for nodes running in THIS host (every manifest node). Mirrors
+     * executeNodeWithRouting above: the work happens in the workflow service, reached over the
+     * same door. `executionId` is the SENDER's own, so a node can only address nodes in the
+     * workflow it is running in.
+     */
+    deliverToNode: async (executionId: string, nodeId: string, handle: string, value: unknown, signal?: string) => {
+      await deliverToNodeInWorkflow({ executionId, nodeId, handle, value, signal });
+    },
+    classes: {
+      PromiseNode,
+      CallbackNode,
+    },
+    types: {
+      NodeInputType,
+      NodeConcurrency: {},
+    },
+  };
+}

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

@@ -0,0 +1,54 @@
+/**
+ * Redis Client Management
+ */
+
+import { Redis } from "ioredis";
+import { boot } from "../boot.js";
+
+let redisClient: Redis | null = null;
+
+export function setRedisClient(client: Redis): void {
+  redisClient = client;
+}
+
+export function getRedisClient(): Redis | null {
+  return redisClient;
+}
+
+/**
+ * Initialise the runtime's shared Redis command client from env, once, at boot.
+ *
+ * Node execution reaches Redis through `executionContext.api.getRedisClient()`
+ * (see executionContext.ts) — used e.g. by the OpenAI/ChatGPT agents to persist
+ * per-conversation state (`openai:conv:*`, `previous_response_id`) so multi-turn
+ * history survives across turns. Without this, getRedisClient() returns null,
+ * the agents log `hasRedis=false`, and every turn starts a NEW conversation.
+ *
+ * This is a normal command connection — distinct from the pub/sub subscriber in
+ * lifecycleBridge.ts (an ioredis connection in subscriber mode can't run GET/SETEX).
+ */
+export function initRuntimeRedis(): void {
+  if (redisClient) return; // already initialised
+  const host = process.env.REDIS_HOST;
+  const port = process.env.REDIS_PORT;
+  if (!host || !port) {
+    console.warn(
+      "[unoverse:runtime] REDIS_HOST/REDIS_PORT not configured — node runtime Redis disabled (agent multi-turn history will not persist)",
+    );
+    return;
+  }
+
+  const client = new Redis({
+    host,
+    port: parseInt(port, 10),
+    password: process.env.REDIS_PASSWORD || undefined,
+    tls: process.env.REDIS_TLS === "true" ? {} : undefined,
+    retryStrategy: (times: number) => Math.min(times * 100, 3000),
+  });
+  client.on("error", (err: Error) => {
+    console.warn(`[unoverse:runtime] Redis client error: ${err.message}`);
+  });
+
+  setRedisClient(client);
+  boot.redis("connected, agent multi-turn history enabled");
+}

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

@@ -0,0 +1,222 @@
+/**
+ * Service Calls
+ * HTTP calls to workflow-service for core node services and analytics
+ */
+
+import { boot } from "../boot.js";
+
+const WORKFLOW_SERVICE_URL = process.env.WORKFLOW_SERVICE_URL || "http://localhost:4101";
+
+/**
+ * Call a service on a core node via workflow service
+ * This enables package nodes (node-service) to call core node services (workflow-service)
+ * Example: OpenAIStream calls GetActiveMCPs.getSchema
+ */
+export async function callServiceViaWorkflow(method: string, params: any, executionContext: any): Promise<any> {
+  // No wired provider is NOT a reason to skip: workflow-service serves platform
+  // tools (memory toolsets gated by workflow memory_config) and re-routes methods
+  // to their real owner by name. The sentinel just satisfies the nodeId field;
+  // calls that nothing can serve fail server-side and return {} as before.
+  const serviceNodeId = executionContext?.serviceNodeId || "__platform";
+
+  try {
+    const response = await fetch(`${WORKFLOW_SERVICE_URL}/service-call`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        nodeId: serviceNodeId,
+        method,
+        params,
+        context: {
+          workflowId: executionContext?.workflowId,
+          executionId: executionContext?.executionId,
+          nodeId: executionContext?.nodeId,
+          credentials: executionContext?.credentials,
+          workflow: executionContext?.workflow,
+          auth: executionContext?.auth,
+          publishingContext: executionContext?.publishingContext,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[node-service] callService failed: ${response.status} ${errorText}`);
+      return {};
+    }
+
+    return await response.json();
+  } catch (error: any) {
+    console.error("[node-service] callService error:", error.message);
+    return {};
+  }
+}
+
+/**
+ * Save token usage by calling workflow service
+ */
+export async function saveTokenUsageToWorkflow(usage: any): Promise<void> {
+  try {
+    const response = await fetch(`${WORKFLOW_SERVICE_URL}/analytics/tokens`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(usage),
+    });
+    if (!response.ok) {
+      console.error(`[node-service] Failed to save token usage: ${response.status}`);
+    }
+  } catch (error) {
+    console.error("[node-service] Error saving token usage:", error);
+  }
+}
+
+/**
+ * Emit NODE_OUTPUT to workflow service so downstream nodes fire.
+ * Used by package hybrid nodes (SmartDocument etc.) whose xstate actor
+ * lives in the workflow-service process.
+ */
+export async function emitNodeOutputToWorkflow(payload: {
+  executionId: string;
+  nodeId: string;
+  output: any;
+}): Promise<void> {
+  try {
+    const response = await fetch(`${WORKFLOW_SERVICE_URL}/emit-node-output`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      console.error(`[node-service] emitNodeOutput failed: ${response.status}`);
+    }
+  } catch (error: any) {
+    console.error("[node-service] emitNodeOutput error:", error.message);
+  }
+}
+
+/**
+ * Hand a value to a NAMED node in the caller's own run, with no edge between them.
+ *
+ * The out-of-process half of the manifest `send:` row: manifest nodes execute in this host, so a
+ * send has to cross to the workflow service the same way a node output does.
+ *
+ * THROWS, unlike `emitNodeOutputToWorkflow` above, and the difference is deliberate. A lost node
+ * output costs a render. A lost delivery costs a loop its next pass, and the loop then reports
+ * success having processed one item — the exact silent failure this mechanism replaced. Better a
+ * stopped run than a wrong answer.
+ */
+export async function deliverToNodeInWorkflow(payload: {
+  executionId: string;
+  nodeId: string;
+  handle: string;
+  value: any;
+  signal?: string;
+}): Promise<void> {
+  let response: Response;
+  try {
+    response = await fetch(`${WORKFLOW_SERVICE_URL}/deliver-to-node`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+  } catch (error: any) {
+    throw new Error(
+      `deliverToNode: could not reach the workflow service to deliver "${payload.nodeId}.${payload.handle}" — ${error.message}`,
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `deliverToNode: the workflow service refused delivery of "${payload.nodeId}.${payload.handle}" (${response.status})`,
+    );
+  }
+}
+
+/**
+ * Save MCP trace by calling workflow service
+ */
+export async function saveMCPTraceToWorkflow(trace: any): Promise<string> {
+  try {
+    const response = await fetch(`${WORKFLOW_SERVICE_URL}/analytics/mcp-trace`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(trace),
+    });
+    if (!response.ok) {
+      console.error(`[node-service] Failed to save MCP trace: ${response.status}`);
+      return "";
+    }
+    const result = (await response.json()) as { traceId?: string };
+    return result.traceId || "";
+  } catch (error) {
+    console.error("[node-service] Error saving MCP trace:", error);
+    return "";
+  }
+}
+
+/**
+ * Persist plugin state to PostgreSQL via workflow-service
+ */
+export async function persistPluginState(plugin: {
+  name: string;
+  version: string;
+  source: "local" | "npm";
+  enabled: boolean;
+  metadata?: any;
+}): Promise<void> {
+  try {
+    const response = await fetch(`${WORKFLOW_SERVICE_URL}/plugins/state`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(plugin),
+    });
+    if (!response.ok) {
+      console.error(`[node-service] Failed to persist plugin state: ${response.status}`);
+    }
+  } catch (error: any) {
+    console.error("[node-service] Error persisting plugin state:", error.message);
+  }
+}
+
+/**
+ * Remove plugin state from PostgreSQL (on uninstall)
+ */
+export async function removePluginState(name: string): Promise<void> {
+  try {
+    const response = await fetch(
+      `${WORKFLOW_SERVICE_URL}/plugins/state/${encodeURIComponent(name)}`,
+      { method: "DELETE", headers: { "Content-Type": "application/json" } },
+    );
+    if (!response.ok) {
+      console.error(`[node-service] Failed to remove plugin state: ${response.status}`);
+    }
+  } catch (error: any) {
+    console.error("[node-service] Error removing plugin state:", error.message);
+  }
+}
+
+/**
+ * Fetch all plugin state from PostgreSQL (for Redis recovery on startup)
+ */
+export async function fetchPluginState(): Promise<Array<{
+  name: string;
+  version: string;
+  source: string;
+  enabled: boolean;
+  metadata: any;
+}>> {
+  try {
+    const response = await fetch(`${WORKFLOW_SERVICE_URL}/plugins/state`);
+    if (!response.ok) return [];
+    const data: any = await response.json();
+    return data.plugins || [];
+  } catch (error: any) {
+    // EXPECTED once in merged mode: the runtime asks :4101 for plugin state before the
+    // in-process engine has bound it, and index.ts re-runs the whole load after the
+    // engine is up. Shouting about a failure that self-heals seconds later is how a log
+    // teaches people to ignore it. Remembered instead, and surfaced by the boot report
+    // only if the retry ALSO came back with nothing.
+    if (boot.isBooting()) boot.pluginStateFetchFailed(error.message);
+    else console.error("[node-service] Error fetching plugin state:", error.message);
+    return [];
+  }
+}