@growthub/cli 0.13.4 → 0.13.6

package/assets/worker-kits/growthub-custom-workspace-starter-v1/QUICKSTART.md

@@ -10,6 +10,25 @@ This kit is the canonical v1 starter primitive. Run `growthub starter init --nam
 
 After that, every customization you make stays yours — the Self-Healing Fork Sync Agent will propose upstream additions non-destructively, honouring your policy.
 
+## Official workspace paths
+
+Workspace 1 stays the blank governed workspace:
+
+```bash
+growthub starter init --name "My Workspace" --out ./my-workspace
+```
+
+Workspace 2 is the opinionated project-management template path. It builds on the same app and adapter surface, but seeds API Registry, Data Source, Sandbox Environment workflow, and dashboard placeholders for project task deltas. It stores no provider secrets, OAuth connection ids, or provider task data.
+
+```bash
+growthub starter init \
+  --name "Project Management Workspace" \
+  --out ./project-management-workspace \
+  --seed-config project-management
+```
+
+After export, set `NANGO_SECRET_KEY` in the workspace runtime, complete provider OAuth, then fill `providerConfigKey`, `connectionIds`, and project identifiers in the Data Model before running the workflow.
+
 ## Run the bundled Vite UI shell
 
 ```bash

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/.env.example

@@ -10,6 +10,14 @@ GROWTHUB_WORKSPACE_PAYMENT_ADAPTER=none
 # - static: local starter catalog only
 GROWTHUB_WORKSPACE_INTEGRATION_ADAPTER=growthub-bridge
 
+# Nango thin adapter — row-scoped, not a workspace-wide adapter.
+# Set NANGO_SECRET_KEY when any api-registry row has connectorKind: "nango".
+# Cloud mode reaches Nango Cloud; self-hosted requires NANGO_HOST_URL.
+NANGO_MODE=cloud
+NANGO_HOST_URL=
+NANGO_ENVIRONMENT=dev
+NANGO_SECRET_KEY=
+
 # Hosted bridge authority
 GROWTHUB_BRIDGE_BASE_URL=https://www.growthub.ai
 GROWTHUB_BRIDGE_INTEGRATIONS_PATH=/api/mcp/accounts

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/README.md

@@ -13,6 +13,10 @@ It intentionally depends on adapter contracts:
 - `GROWTHUB_BRIDGE_ACCESS_TOKEN`
 - `GROWTHUB_BRIDGE_USER_ID`
 - `GROWTHUB_WORKSPACE_BYO_CONNECTIONS_JSON`
+- `NANGO_SECRET_KEY` (required when any api-registry row uses `connectorKind: "nango"`)
+- `NANGO_HOST_URL` (self-hosted Nango only)
+- `NANGO_ENVIRONMENT` (default `dev`)
+- `NANGO_MODE` (`cloud` | `self-hosted`, default `cloud`)
 
 The Growthub local-first operator shell remains at `../../studio`.
 

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/integrations/nango/action/execute/route.js

@@ -0,0 +1,60 @@
+/**
+ * POST /api/workspace/integrations/nango/action/execute
+ *
+ * Executes a declared Nango action function against the connection
+ * identified by `providerConfigKey` + `connectionId`. Used by workspace
+ * agents as a tool-call surface.
+ *
+ * Request body:
+ *   {
+ *     providerConfigKey: string,
+ *     connectionId: string,
+ *     action: string,              // action function name from nango.yaml
+ *     input?: object | array       // arguments to the action
+ *   }
+ *
+ * Response — success: 200 { ok: true, action, providerConfigKey, connectionId, result, environment }
+ * Response — validation failure: 400 { ok: false, error, details }
+ * Response — Nango not configured: 503 { ok: false, error, code }
+ * Response — upstream failure: 502 { ok: false, error }
+ */
+
+import { NextResponse } from "next/server";
+import { executeAction, validateActionExecuteRequest } from "@/lib/adapters/integrations/nango";
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "invalid JSON body" }, { status: 400 });
+  }
+
+  let validated;
+  try {
+    validated = validateActionExecuteRequest(body);
+  } catch (error) {
+    return NextResponse.json(
+      { ok: false, error: error.message, details: error.details || null },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const result = await executeAction(validated);
+    return NextResponse.json({ ok: true, ...result });
+  } catch (error) {
+    if (error.code === "NANGO_NOT_CONFIGURED" || error.code === "NANGO_SDK_UNAVAILABLE" || error.code === "NANGO_SDK_SHAPE") {
+      return NextResponse.json(
+        { ok: false, error: error.message, code: error.code },
+        { status: 503 }
+      );
+    }
+    return NextResponse.json(
+      { ok: false, error: error?.message || "nango action execution failed" },
+      { status: 502 }
+    );
+  }
+}
+
+export { POST };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/integrations/nango/actions/route.js

@@ -0,0 +1,50 @@
+/**
+ * GET /api/workspace/integrations/nango/actions
+ *
+ * Lists the actions declared in `nango.yaml` for a given provider config key
+ * (or, when no key is provided, returns the full discoverable set). The
+ * response shape is MCP-compatible: each action exposes a name and (when
+ * provided by Nango) an input/output schema.
+ *
+ * Query parameters (optional):
+ *   - providerConfigKey  filter to actions for a single provider
+ *
+ * Response shape:
+ *   { ok: true, providerConfigKey, probedShape, actions: Array, hint: string|null }
+ */
+
+import { NextResponse } from "next/server";
+import { listActions, validateActionsListInput } from "@/lib/adapters/integrations/nango";
+
+async function GET(request) {
+  const url = new URL(request.url);
+  const raw = {
+    providerConfigKey: url.searchParams.get("providerConfigKey") || undefined
+  };
+  let input;
+  try {
+    input = validateActionsListInput(raw);
+  } catch (error) {
+    return NextResponse.json(
+      { ok: false, error: error.message, details: error.details || null },
+      { status: 400 }
+    );
+  }
+  try {
+    const result = await listActions(input);
+    return NextResponse.json({ ok: true, ...result });
+  } catch (error) {
+    if (error.code === "NANGO_NOT_CONFIGURED" || error.code === "NANGO_SDK_UNAVAILABLE") {
+      return NextResponse.json(
+        { ok: false, error: error.message, code: error.code },
+        { status: 503 }
+      );
+    }
+    return NextResponse.json(
+      { ok: false, error: error?.message || "nango actions list failed" },
+      { status: 502 }
+    );
+  }
+}
+
+export { GET };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/integrations/nango/connect-session/route.js

@@ -0,0 +1,68 @@
+/**
+ * POST /api/workspace/integrations/nango/connect-session
+ *
+ * Creates a Nango Connect Session for the given providerConfigKey and
+ * returns a short-lived connect_link the browser opens to start OAuth.
+ * The Nango Connect UI mints tokens directly against Nango — the workspace
+ * never sees the resulting OAuth credentials. The token returned here is a
+ * Connect Session token (handoff only), not a provider credential.
+ *
+ * Lifecycle: Nango creates the connectionId AFTER the user completes OAuth
+ * and delivers it through the auth webhook. A normal Connect Session
+ * therefore does NOT need a connectionId as input — only the explicit
+ * Reconnect path (`reconnect: true`) operates on an existing connectionId.
+ *
+ * Request body:
+ *   {
+ *     providerConfigKey: string,         // required, alphanumeric (+ _.-) <= 64 chars
+ *     reconnect?: boolean,                // true → use the SDK's reconnect-session path
+ *     connectionId?: string,              // REQUIRED when reconnect=true; ignored for a normal Create Connect Session
+ *     endUser?: { id?: string, email?: string },
+ *     tags?: Record<string, string>      // echoed back in the Nango auth webhook so the workspace can map the eventual connectionId to the originating row
+ *   }
+ *
+ * Response — success: 200 { ok: true, providerConfigKey, environment, mode, token, connectLink, sdkMethod, tagsEchoed }
+ * Response — validation failure: 400 { ok: false, error, details }
+ * Response — Nango not configured / SDK missing: 503 { ok: false, error, code }
+ * Response — upstream failure: 502 { ok: false, error }
+ */
+
+import { NextResponse } from "next/server";
+import { createConnectSession, validateConnectSessionRequest } from "@/lib/adapters/integrations/nango";
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "invalid JSON body" }, { status: 400 });
+  }
+
+  let validated;
+  try {
+    validated = validateConnectSessionRequest(body);
+  } catch (error) {
+    return NextResponse.json(
+      { ok: false, error: error.message, details: error.details || null },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const result = await createConnectSession(validated);
+    return NextResponse.json({ ok: true, ...result });
+  } catch (error) {
+    if (error.code === "NANGO_NOT_CONFIGURED" || error.code === "NANGO_SDK_UNAVAILABLE" || error.code === "NANGO_SDK_SHAPE") {
+      return NextResponse.json(
+        { ok: false, error: error.message, code: error.code },
+        { status: 503 }
+      );
+    }
+    return NextResponse.json(
+      { ok: false, error: error?.message || "nango connect session failed" },
+      { status: 502 }
+    );
+  }
+}
+
+export { POST };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/integrations/nango/connection-status/route.js

@@ -0,0 +1,56 @@
+/**
+ * POST /api/workspace/integrations/nango/connection-status
+ *
+ * Returns the safe (non-credential) status summary for a specific Nango
+ * connection. Used by the NangoConnectionPanel sidecar to verify a
+ * per-row connection without exposing OAuth tokens to the browser.
+ *
+ * Request body:
+ *   { providerConfigKey: string, connectionId: string }
+ *
+ * Response — connected: 200 { ok: true, status: "connected", providerConfigKey, connectionId, environment, connection: { ...safe fields... } }
+ * Response — not yet connected: 200 { ok: true, status: "not-connected", providerConfigKey, connectionId, environment, reason }
+ * Response — validation failure: 400 { ok: false, error, details }
+ * Response — Nango not configured: 503 { ok: false, error, code }
+ * Response — upstream failure: 502 { ok: false, error }
+ */
+
+import { NextResponse } from "next/server";
+import { getConnectionSummary, validateConnectionSummaryRequest } from "@/lib/adapters/integrations/nango";
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "invalid JSON body" }, { status: 400 });
+  }
+
+  let validated;
+  try {
+    validated = validateConnectionSummaryRequest(body);
+  } catch (error) {
+    return NextResponse.json(
+      { ok: false, error: error.message, details: error.details || null },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const result = await getConnectionSummary(validated);
+    return NextResponse.json({ ok: true, ...result });
+  } catch (error) {
+    if (error.code === "NANGO_NOT_CONFIGURED" || error.code === "NANGO_SDK_UNAVAILABLE" || error.code === "NANGO_SDK_SHAPE") {
+      return NextResponse.json(
+        { ok: false, error: error.message, code: error.code },
+        { status: 503 }
+      );
+    }
+    return NextResponse.json(
+      { ok: false, error: error?.message || "nango connection status failed" },
+      { status: 502 }
+    );
+  }
+}
+
+export { POST };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/integrations/nango/proxy/route.js

@@ -0,0 +1,67 @@
+/**
+ * POST /api/workspace/integrations/nango/proxy
+ *
+ * Proxies an API request through Nango using the connection identified by
+ * `providerConfigKey` + `connectionId`. The Nango SDK injects credentials
+ * server-side; the browser never holds the upstream provider's auth.
+ *
+ * Request body:
+ *   {
+ *     providerConfigKey: string,   // Nango integration config key
+ *     connectionId: string,         // Nango connection id
+ *     method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE",
+ *     endpoint: string,             // path or absolute URL
+ *     headers?: object,             // forbidden: Authorization, X-API-Key, etc.
+ *     params?: object,
+ *     data?: any,
+ *     retries?: number,             // 0..10
+ *     timeoutMs?: number            // 0..60000
+ *   }
+ *
+ * Response — success:
+ *   { ok: true, status: number, data: any, environment: string }
+ *
+ * Response — validation failure: 400 { ok: false, error, details }
+ * Response — Nango not configured: 503 { ok: false, error, code }
+ * Response — upstream failure: 502 { ok: false, error }
+ */
+
+import { NextResponse } from "next/server";
+import { proxyRequest, validateProxyRequest } from "@/lib/adapters/integrations/nango";
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "invalid JSON body" }, { status: 400 });
+  }
+
+  let validated;
+  try {
+    validated = validateProxyRequest(body);
+  } catch (error) {
+    return NextResponse.json(
+      { ok: false, error: error.message, details: error.details || null },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const result = await proxyRequest(validated);
+    return NextResponse.json({ ok: true, ...result });
+  } catch (error) {
+    if (error.code === "NANGO_NOT_CONFIGURED" || error.code === "NANGO_SDK_UNAVAILABLE" || error.code === "NANGO_SDK_SHAPE") {
+      return NextResponse.json(
+        { ok: false, error: error.message, code: error.code },
+        { status: 503 }
+      );
+    }
+    return NextResponse.json(
+      { ok: false, error: error?.message || "nango proxy failed" },
+      { status: 502 }
+    );
+  }
+}
+
+export { POST };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/integrations/nango/status/route.js

@@ -0,0 +1,50 @@
+/**
+ * GET /api/workspace/integrations/nango/status
+ *
+ * Returns Nango connection health for the no-code Integrations panel.
+ *
+ * Query parameters (all optional):
+ *   - providerConfigKey  probe a specific provider connection
+ *   - connectionId       probe a specific connection (paired with providerConfigKey)
+ *   - mode               override mode for the probe ("cloud" | "self-hosted")
+ *   - hostUrl            override host URL for self-hosted probes
+ *
+ * Response shape:
+ *   { status: "connected" | "disconnected" | "unconfigured", ... }
+ *
+ * Authority contract: never returns the Nango secret key. Never echoes
+ * credential-shaped fields from upstream SDK responses.
+ */
+
+import { NextResponse } from "next/server";
+import { getStatus, validateConnectionStatusRequest } from "@/lib/adapters/integrations/nango";
+
+async function GET(request) {
+  const url = new URL(request.url);
+  const raw = {
+    providerConfigKey: url.searchParams.get("providerConfigKey") || undefined,
+    connectionId: url.searchParams.get("connectionId") || undefined,
+    mode: url.searchParams.get("mode") || undefined,
+    hostUrl: url.searchParams.get("hostUrl") || undefined
+  };
+  let input;
+  try {
+    input = validateConnectionStatusRequest(raw);
+  } catch (error) {
+    return NextResponse.json(
+      { error: error.message, details: error.details || null },
+      { status: 400 }
+    );
+  }
+  try {
+    const result = await getStatus(input);
+    return NextResponse.json(result);
+  } catch (error) {
+    return NextResponse.json(
+      { error: error?.message || "nango status probe failed" },
+      { status: 500 }
+    );
+  }
+}
+
+export { GET };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/metadata-graph/route.js

@@ -0,0 +1,184 @@
+/**
+ * GET /api/workspace/metadata-graph
+ *
+ * Growthub Workspace Metadata Graph V1 — read-only projection.
+ *
+ * Combines the governed workspace config and the live source-record sidecar
+ * into a typed metadata store and a node/edge graph. Consumers (the UI
+ * inspector, the workspace helper agent, and external operators) use this
+ * envelope to ask dependency questions without re-deriving widget/workflow
+ * contracts inside every component.
+ *
+ * Optional query parameters:
+ *   - staleKind: "object" | "field" | "sourceRecord" | "workflow" | "agentHost" | "widget"
+ *   - staleId:   the corresponding metadata id (for `field`, use
+ *                "<objectId>::<fieldId>")
+ *
+ *   When both are provided the response `stale.groups` and `stale.reasons`
+ *   reflect `selectStaleMetadataGroups({ kind, id })`. When omitted the
+ *   stale section returns the empty baseline.
+ *
+ * Authority invariants:
+ *   - GET only. PATCH / POST / PUT / DELETE are not exposed. Writes still
+ *     flow through the existing governed routes
+ *     (`PATCH /api/workspace`, `POST /api/workspace/refresh-sources`,
+ *     `POST /api/workspace/sandbox-run`).
+ *   - growthub.config.json remains the authoritative artifact.
+ *   - No secrets are returned. Field metadata derived from secret-shaped
+ *     column names is marked `isSecret: true` but no value is echoed.
+ *   - Failures during read OR projection fall back to an empty store with
+ *     warnings — this route never throws.
+ */
+
+import { NextResponse } from "next/server";
+import { readWorkspaceConfig, readWorkspaceSourceRecords } from "@/lib/workspace-config";
+import { buildWorkspaceMetadataStore } from "@/lib/workspace-metadata-store";
+import { buildWorkspaceMetadataGraph } from "@/lib/workspace-metadata-graph";
+import { selectStaleMetadataGroups } from "@/lib/workspace-metadata-selectors";
+
+const ENVELOPE_KIND = "growthub-workspace-metadata-graph-v1";
+const ENVELOPE_VERSION = 1;
+
+function emptyMetadataStore() {
+  return {
+    kind: "growthub-workspace-metadata-store-v1",
+    version: 1,
+    objects: [],
+    fields: [],
+    views: [],
+    filters: [],
+    sorts: [],
+    widgets: [],
+    dashboards: [],
+    workflows: [],
+    workflowNodes: [],
+    workflowActions: [],
+    runInputs: [],
+    agentHosts: [],
+    sandboxes: [],
+    integrations: [],
+    integrationEntities: [],
+    sourceRecords: [],
+    runs: [],
+    outputArtifacts: [],
+    workerKits: [],
+    pipelineHealth: [],
+    warnings: []
+  };
+}
+
+async function GET(request) {
+  const warnings = [];
+
+  let workspaceConfig = null;
+  try {
+    workspaceConfig = await readWorkspaceConfig();
+  } catch (error) {
+    warnings.push(`Failed to read workspace config: ${error?.message || "unknown error"}`);
+  }
+
+  let workspaceSourceRecords = {};
+  try {
+    workspaceSourceRecords = (await readWorkspaceSourceRecords()) || {};
+  } catch (error) {
+    warnings.push(`Failed to read source records sidecar: ${error?.message || "unknown error"}`);
+  }
+
+  // Defensive: helpers are designed to never throw on partial/unknown input,
+  // but the route must remain HTTP-200 even if an unexpected exception bubbles
+  // up (so the UI inspector and agents always get a typed envelope).
+  let metadataStore;
+  try {
+    metadataStore = buildWorkspaceMetadataStore({
+      workspaceConfig: workspaceConfig || {},
+      workspaceSourceRecords
+    });
+    warnings.push(...metadataStore.warnings);
+  } catch (error) {
+    warnings.push(`Failed to build metadata store: ${error?.message || "unknown error"}`);
+    metadataStore = emptyMetadataStore();
+  }
+
+  let graph;
+  try {
+    graph = buildWorkspaceMetadataGraph(metadataStore);
+    warnings.push(...graph.warnings);
+  } catch (error) {
+    warnings.push(`Failed to build metadata graph: ${error?.message || "unknown error"}`);
+    graph = { kind: "growthub-workspace-metadata-graph-v1", version: 1, nodes: [], edges: [], warnings: [] };
+  }
+
+  // Optional stale-group selector via query params.
+  let staleGroups = [];
+  let staleReasons = [];
+  try {
+    const url = request && request.url ? new URL(request.url) : null;
+    const staleKind = url ? (url.searchParams.get("staleKind") || "").trim() : "";
+    const staleId = url ? (url.searchParams.get("staleId") || "").trim() : "";
+    if (staleKind && staleId) {
+      const result = selectStaleMetadataGroups(metadataStore, { kind: staleKind, id: staleId });
+      staleGroups = Array.isArray(result?.groups) ? result.groups : [];
+      staleReasons = Array.isArray(result?.reasons) ? result.reasons : [];
+    }
+  } catch (error) {
+    warnings.push(`Failed to compute stale groups: ${error?.message || "unknown error"}`);
+  }
+
+  return NextResponse.json({
+    kind: ENVELOPE_KIND,
+    version: ENVELOPE_VERSION,
+    authority: {
+      config: "growthub.config.json",
+      sourceRecords: "growthub.source-records.json",
+      readOnlyProjection: true
+    },
+    metadata: {
+      objects: metadataStore.objects,
+      fields: metadataStore.fields,
+      views: metadataStore.views,
+      filters: metadataStore.filters,
+      sorts: metadataStore.sorts,
+      widgets: metadataStore.widgets,
+      dashboards: metadataStore.dashboards,
+      workflows: metadataStore.workflows,
+      workflowNodes: metadataStore.workflowNodes,
+      workflowActions: metadataStore.workflowActions,
+      runInputs: metadataStore.runInputs,
+      agentHosts: metadataStore.agentHosts,
+      sandboxes: metadataStore.sandboxes,
+      integrations: metadataStore.integrations,
+      integrationEntities: metadataStore.integrationEntities,
+      sourceRecords: metadataStore.sourceRecords,
+      runs: metadataStore.runs,
+      outputArtifacts: metadataStore.outputArtifacts,
+      workerKits: metadataStore.workerKits,
+      pipelineHealth: metadataStore.pipelineHealth
+    },
+    graph: {
+      nodes: graph.nodes,
+      edges: graph.edges
+    },
+    stale: {
+      groups: staleGroups,
+      reasons: staleReasons
+    },
+    warnings,
+    selectors: {
+      // Manifest of selectors the route honours. Only `selectStaleMetadataGroups`
+      // is wired through HTTP (via `?staleKind=&staleId=`). The remaining
+      // selectors are exposed as importable helpers for server-side consumers
+      // and the read-only inspector; they are NOT toggled through query
+      // params in V1.
+      httpEnabled: ["selectStaleMetadataGroups"],
+      helperOnly: [
+        "selectWidgetRequiredFields",
+        "selectWorkflowNodeInputSchema",
+        "selectObjectFilterableFields",
+        "selectObjectSortableFields",
+        "selectRunLineage"
+      ]
+    }
+  });
+}
+
+export { GET };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/sandbox-run/route.js

@@ -392,6 +392,12 @@ function buildRunResponse({
     base.runInputs = runInputs;
     base.inputSummary = summarizeRunInputs(runInputs);
   }
+  if (result && typeof result === "object" && result.swarm && typeof result.swarm === "object") {
+    base.swarm = result.swarm;
+  }
+  if (result && typeof result === "object" && Array.isArray(result.logTree)) {
+    base.logTree = result.logTree;
+  }
   base.exports = {
     available: ["download-json", "copy-output", "download-stdout", "download-stderr", "download-log-node"],
     external: []
@@ -558,11 +564,28 @@ async function POST(request) {
       workspaceConfig,
       row: rowForRun,
       timeoutMs,
-      runInputs: normalizedRunInputs
+      runInputs: normalizedRunInputs,
+      executionContext: {
+        runId,
+        ranAt,
+        runtime,
+        agentHost,
+        adapterId,
+        env,
+        envRefSlugs,
+        envRefsMissing,
+        envRefsResolved,
+        networkAllow,
+        allowList,
+        instructions,
+        command,
+        timeoutMs,
+        sandboxName: rowForRun.Name || name
+      }
     });
     if (graphResult !== null) {
       result = graphResult;
-      effectiveAdapterId = "orchestration-graph";
+      effectiveAdapterId = String(graphResult?.adapterMeta?.adapter || "").trim() || "orchestration-graph";
     }
   }