@growthub/cli 0.13.0 → 0.13.2

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/workspace-rail.jsx

@@ -12,7 +12,7 @@
  *   │ [🏠 Home] [💬 Chat]      [✶+  Ask helper]    │  Tab row
  *   ├──────────────────────────────────────────────┤
  *   │ HOME tab body:           CHAT tab body:      │
- *   │  Dashboards               Latest             │
+ *   │  Builder                  Latest             │
  *   │  Data Model               💬 Best Skills     │
  *   │  Management               💬 Casual greet    │
  *   │  Workspace Settings       (… more threads)   │
@@ -26,20 +26,21 @@
  *
  * Surface-specific slots (`dashboardsSlot`, `dataModelSlot`,
  * `managementSlot`, `settingsSlot`) let the page inject its own
- * Dashboards / Data Model / Management / Workspace Settings behaviour
+ * Builder / Management / Workspace Settings behaviour
  * while keeping the visual treatment identical across every page.
  */
 
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import Link from "next/link";
-import { usePathname, useRouter } from "next/navigation";
+import { usePathname, useRouter, useSearchParams } from "next/navigation";
 import {
   Archive,
   ChevronDown,
   ChevronRight,
   Folder,
   FolderPlus,
+  GitBranch,
   Home,
   LayoutDashboard,
   MessageCircle,
@@ -64,6 +65,7 @@ import {
   nextNavFolderId,
   nextNavItemId,
 } from "@/lib/workspace-helper-apply";
+import { listAvailableWorkflows } from "@/lib/nav-workflows";
 import { ICON_PICKER_SET, LucideIcon } from "./data-model/components/dm-shared.jsx";
 
 function textColorForAccent(accent) {
@@ -172,6 +174,7 @@ const NAV_FOLDER_STYLE_DEFAULT = { icon: "Folder", color: "#f97316", iconBg: "#f
 const NAV_ITEM_STYLE_DEFAULT = {
   dashboard: { icon: "LayoutDashboard", color: "#3b82f6", iconBg: "#eff6ff" },
   view: { icon: "Table", color: "#14b8a6", iconBg: "#f0fdfa" },
+  workflow: { icon: "GitBranch", color: "#8b5cf6", iconBg: "#f5f3ff" },
 };
 
 /** Default visible rows before scroll — keeps the rail from growing unbounded. */
@@ -394,6 +397,7 @@ function NavFoldersSection({
   onPatchNavFolders,
 }) {
   const router = useRouter();
+  const searchParams = useSearchParams();
   const [creating, setCreating] = useState(false);
   const [createDraft, setCreateDraft] = useState("");
   const [createDiscardWarn, setCreateDiscardWarn] = useState(false);
@@ -401,15 +405,16 @@ function NavFoldersSection({
   const [menuAnchor, setMenuAnchor] = useState(null);
   const [customizeTarget, setCustomizeTarget] = useState(null);
   const [discardWarn, setDiscardWarn] = useState(false);
-  const [addPickerFor, setAddPickerFor] = useState(null); // { folderId, kind: "dashboard"|"view" }
+  const [addPickerFor, setAddPickerFor] = useState(null); // { folderId, kind: "dashboard"|"view"|"workflow" }
   const [filterQuery, setFilterQuery] = useState("");
-  const [filterType, setFilterType] = useState("all"); // all | dashboard | view
+  const [filterType, setFilterType] = useState("all"); // all | dashboard | view | workflow
   const [filterMenuOpen, setFilterMenuOpen] = useState(false);
   const [sectionCollapsed, setSectionCollapsed] = useState(true);
 
   const rows = useMemo(() => getNavFolderRows(workspaceConfig), [workspaceConfig]);
   const dashboards = useMemo(() => listAvailableDashboards(workspaceConfig), [workspaceConfig]);
   const viewableObjects = useMemo(() => listAvailableObjectsForViews(workspaceConfig), [workspaceConfig]);
+  const workflows = useMemo(() => listAvailableWorkflows(workspaceConfig), [workspaceConfig]);
   const filteredEntries = useMemo(
     () => filterNavFolderRows(rows, filterQuery, filterType),
     [rows, filterQuery, filterType],
@@ -680,6 +685,28 @@ function NavFoldersSection({
     await writeRows(next);
   }, [rows, writeRows]);
 
+  const addWorkflowItem = useCallback(async (folderId, workflow) => {
+    setAddPickerFor(null);
+    setOpenMenuId(null);
+    const style = NAV_ITEM_STYLE_DEFAULT.workflow;
+    const item = {
+      id: nextNavItemId(),
+      type: "workflow",
+      objectId: workflow.objectId,
+      rowId: workflow.rowId,
+      fieldName: "orchestrationGraph",
+      label: workflow.label,
+      icon: style.icon,
+      color: style.color,
+      iconBg: style.iconBg,
+    };
+    const next = rows.map((row) => {
+      if (row.id !== folderId) return row;
+      return { ...row, items: [...(row.items || []), item] };
+    });
+    await writeRows(next);
+  }, [rows, writeRows]);
+
   // ── Drag-and-drop ────────────────────────────────────────────────────
   //
   // HTML5 DnD with a tiny in-ref state machine; mirrors Twenty's
@@ -768,9 +795,9 @@ function NavFoldersSection({
   };
 
   const openDashboardItem = (item) => {
-    // Dashboards are top-level surfaces; the builder reads the active
+    // Builder items are top-level surfaces; the builder reads the active
     // dashboard from query params if present. Other surfaces simply
-    // navigate home; the user lands on the dashboards list. This keeps
+    // navigate home; the user lands on the Builder list. This keeps
     // the rail itself agnostic of surface-specific routing.
     router.push(`/?dashboard=${encodeURIComponent(item.refId)}`);
   };
@@ -779,6 +806,13 @@ function NavFoldersSection({
     router.push(`/data-model?object=${encodeURIComponent(item.objectId || "")}`);
   };
 
+  const openWorkflowItem = (item) => {
+    const objectId = encodeURIComponent(item.objectId || "");
+    const row = encodeURIComponent(item.rowId || "");
+    const field = encodeURIComponent(item.fieldName || "orchestrationGraph");
+    router.push(`/workflows?object=${objectId}&row=${row}&field=${field}`);
+  };
+
   const renderItemMenu = (folder, item) => {
     const composedId = `${folder.id}::${item.id}`;
     const isMenuOpen = openMenuId === composedId;
@@ -862,9 +896,13 @@ function NavFoldersSection({
   const renderItemRow = (folder, item) => {
     const composedId = `${folder.id}::${item.id}`;
     const isMenuOpen = openMenuId === composedId;
-    const isActive = item.type === "view" && pathname.startsWith(`/views/${encodeURIComponent(item.id)}`);
+    const isActive = item.type === "view" && pathname.startsWith(`/views/${encodeURIComponent(item.id)}`)
+      || (item.type === "workflow"
+        && pathname.startsWith("/workflows")
+        && searchParams.get("object") === item.objectId
+        && searchParams.get("row") === item.rowId);
     const style = navItemStyle(item);
-    const typeHint = item.type === "dashboard" ? "Dashboard" : "View";
+    const typeHint = item.type === "dashboard" ? "Dashboard" : item.type === "workflow" ? "Workflow" : "View";
     return (
       <li
         key={item.id}
@@ -880,7 +918,11 @@ function NavFoldersSection({
           <button
             type="button"
             className="workspace-rail-nav-row-main"
-            onClick={() => (item.type === "dashboard" ? openDashboardItem(item) : openViewItem(item))}
+            onClick={() => {
+              if (item.type === "dashboard") openDashboardItem(item);
+              else if (item.type === "workflow") openWorkflowItem(item);
+              else openViewItem(item);
+            }}
             title={`${item.label || item.refId || item.objectId} · ${typeHint}`}
           >
             <NavIconBadge icon={style.icon} color={style.color} iconBg={style.iconBg} />
@@ -984,6 +1026,19 @@ function NavFoldersSection({
                 >
                   <TableIcon size={13} aria-hidden="true" /> Add view
                 </button>
+            <button
+              type="button"
+              role="menuitem"
+                  className="workspace-rail-thread-menu-item"
+                  disabled={workflows.length === 0}
+                  onClick={() => {
+                    setOpenMenuId(null);
+                    setMenuAnchor(null);
+                    setAddPickerFor({ folderId: folder.id, kind: "workflow" });
+                  }}
+                >
+                  <GitBranch size={13} aria-hidden="true" /> Add workflow
+                </button>
             <button
               type="button"
               role="menuitem"
@@ -1060,7 +1115,13 @@ function NavFoldersSection({
     <NavFolderPickerOverlay onClose={() => setAddPickerFor(null)}>
       <div className="workspace-rail-folder-picker" onClick={(e) => e.stopPropagation()}>
         <div className="workspace-rail-folder-picker-head">
-          <strong>{addPickerFor.kind === "dashboard" ? "Add dashboard" : "Add view"}</strong>
+          <strong>
+            {addPickerFor.kind === "dashboard"
+              ? "Add dashboard"
+              : addPickerFor.kind === "workflow"
+                ? "Add workflow"
+                : "Add view"}
+          </strong>
           <button
             type="button"
             className="workspace-rail-folder-picker-close"
@@ -1088,23 +1149,45 @@ function NavFoldersSection({
                   </button>
                 </li>
               ))
-            : viewableObjects.map((o) => (
-                <li key={o.id}>
-                  <button
-                    type="button"
-                    className="workspace-rail-folder-picker-item"
-                    onClick={() => addViewItem(addPickerFor.folderId, o)}
-                  >
-                    <NavIconBadge
-                      icon={NAV_ITEM_STYLE_DEFAULT.view.icon}
-                      color={NAV_ITEM_STYLE_DEFAULT.view.color}
-                      iconBg={NAV_ITEM_STYLE_DEFAULT.view.iconBg}
-                    />
-                    <span>{o.label}</span>
-                    <span className="workspace-rail-folder-picker-hint">{o.columns.length} field{o.columns.length === 1 ? "" : "s"}</span>
-                  </button>
-                </li>
-              ))}
+            : addPickerFor.kind === "workflow"
+              ? workflows.map((w) => (
+                  <li key={`${w.objectId}:${w.rowId}`}>
+                    <button
+                      type="button"
+                      className="workspace-rail-folder-picker-item"
+                      onClick={() => addWorkflowItem(addPickerFor.folderId, w)}
+                    >
+                      <NavIconBadge
+                        icon={NAV_ITEM_STYLE_DEFAULT.workflow.icon}
+                        color={NAV_ITEM_STYLE_DEFAULT.workflow.color}
+                        iconBg={NAV_ITEM_STYLE_DEFAULT.workflow.iconBg}
+                      />
+                      <span className="workspace-rail-folder-picker-item-text">
+                        <span>{w.label}</span>
+                        <span className="workspace-rail-folder-picker-hint">
+                          {w.objectLabel} · {w.status} · {w.graphNodeCount} node{w.graphNodeCount === 1 ? "" : "s"}
+                        </span>
+                      </span>
+                    </button>
+                  </li>
+                ))
+              : viewableObjects.map((o) => (
+                  <li key={o.id}>
+                    <button
+                      type="button"
+                      className="workspace-rail-folder-picker-item"
+                      onClick={() => addViewItem(addPickerFor.folderId, o)}
+                    >
+                      <NavIconBadge
+                        icon={NAV_ITEM_STYLE_DEFAULT.view.icon}
+                        color={NAV_ITEM_STYLE_DEFAULT.view.color}
+                        iconBg={NAV_ITEM_STYLE_DEFAULT.view.iconBg}
+                      />
+                      <span>{o.label}</span>
+                      <span className="workspace-rail-folder-picker-hint">{o.columns.length} field{o.columns.length === 1 ? "" : "s"}</span>
+                    </button>
+                  </li>
+                ))}
         </ul>
       </div>
     </NavFolderPickerOverlay>
@@ -1154,7 +1237,7 @@ function NavFoldersSection({
           <input
             type="search"
             className="workspace-rail-folders-search-input"
-            placeholder="Filter folders & views"
+            placeholder="Filter folders & shortcuts"
             value={filterQuery}
             onChange={(e) => setFilterQuery(e.target.value)}
             aria-label="Filter folders and views by name"
@@ -1203,6 +1286,7 @@ function NavFoldersSection({
                   { id: "all", label: "All" },
                   { id: "dashboard", label: "Dashboards" },
                   { id: "view", label: "Views" },
+                  { id: "workflow", label: "Workflows" },
                 ].map((opt) => (
                   <button
                     key={opt.id}
@@ -1579,7 +1663,7 @@ export function WorkspaceRail({
         <nav className="workspace-nav" aria-label="Workspace pages">
           {dashboardsSlot ?? (
             <Link href="/" className={pathname === "/" ? "active" : undefined}>
-              Dashboards
+              Builder
             </Link>
           )}
           {dataModelSlot ?? (

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/data-model/field-contracts.js

@@ -27,6 +27,7 @@ const SANDBOX_ENVIRONMENT_FIELDS = {
   },
   envRefs: { editor: "env-ref-multiselect" },
   lastResponse: { editor: "json-preview", readonly: true },
+  orchestrationGraph: { editor: "orchestration-graph", readonly: true },
   lastRunId: { editor: "readonly-text" },
   lastSourceId: { editor: "readonly-text" },
   resolverTemplateId: { editor: "readonly-text" },

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/nav-workflows.js

@@ -0,0 +1,54 @@
+/**
+ * Folder workflow shortcuts — discover sandbox-environment rows for nav-folders.
+ * Shortcuts reference rows; they do not copy orchestrationGraph JSON.
+ */
+
+import { parseOrchestrationGraph } from "./orchestration-graph.js";
+
+const HIDDEN_SANDBOX_OBJECT_IDS = new Set(["workspace-helper-sandbox"]);
+
+function sandboxRowId(row) {
+  return String(row?.Name || row?.name || row?.slug || row?.id || "").trim();
+}
+
+function listAvailableWorkflows(workspaceConfig) {
+  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  const out = [];
+  for (const object of objects) {
+    if (object?.objectType !== "sandbox-environment") continue;
+    if (HIDDEN_SANDBOX_OBJECT_IDS.has(String(object?.id || ""))) continue;
+    const objectId = String(object?.id || "").trim();
+    if (!objectId) continue;
+    const objectLabel = String(object?.label || "Sandbox Environment").trim();
+    const rows = Array.isArray(object?.rows) ? object.rows : [];
+    for (const row of rows) {
+      const rowId = sandboxRowId(row);
+      if (!rowId) continue;
+      const graph = parseOrchestrationGraph(row?.orchestrationGraph || row?.orchestrationConfig);
+      const graphNodeCount = Array.isArray(graph?.nodes) ? graph.nodes.length : 0;
+      out.push({
+        objectId,
+        rowId,
+        label: rowId,
+        status: String(row?.lifecycleStatus || row?.status || "draft").trim(),
+        version: String(row?.version || "1").trim(),
+        graphNodeCount,
+        objectLabel,
+      });
+    }
+  }
+  return out.sort((a, b) => a.label.localeCompare(b.label));
+}
+
+function findSandboxRowByWorkflowRef(workspaceConfig, objectId, rowId) {
+  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  const object = objects.find((o) => o?.id === objectId && o?.objectType === "sandbox-environment");
+  if (!object) return { object: null, row: null, rowIndex: -1 };
+  const wanted = String(rowId || "").trim();
+  const rows = Array.isArray(object.rows) ? object.rows : [];
+  const rowIndex = rows.findIndex((row) => sandboxRowId(row) === wanted);
+  if (rowIndex < 0) return { object, row: null, rowIndex: -1 };
+  return { object, row: rows[rowIndex], rowIndex };
+}
+
+export { listAvailableWorkflows, findSandboxRowByWorkflowRef, sandboxRowId };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/orchestration-graph-runner.js

@@ -0,0 +1,322 @@
+/**
+ * Server-side growthub-native orchestration graph execution for sandbox-run.
+ */
+
+import {
+  applyFieldMap,
+  applyFilters,
+  extractApiRegistryCallNode,
+  extractInputNode,
+  extractTransformConfig,
+  normalizeJsonAtPath,
+  parseOrchestrationGraph,
+  redactSecretsFromText,
+  substituteVariables
+} from "./orchestration-graph.js";
+
+function normalizeMethod(value) {
+  const method = String(value || "GET").trim().toUpperCase();
+  return ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method) ? method : "GET";
+}
+
+function buildUrl(record, inputPayload) {
+  const baseUrl = String(record?.baseUrl || "").trim();
+  let endpoint = String(record?.endpoint || "").trim();
+  endpoint = substituteVariables(endpoint, inputPayload);
+  const raw = endpoint || baseUrl;
+  if (!raw) throw new Error("baseUrl or endpoint is required");
+  if (/^https?:\/\//i.test(endpoint)) return endpoint;
+  if (!baseUrl) throw new Error("baseUrl is required when endpoint is relative");
+  return `${baseUrl.replace(/\/+$/, "")}/${endpoint.replace(/^\/+/, "")}`;
+}
+
+function envKeyCandidates(ref) {
+  const token = String(ref || "")
+    .trim()
+    .replace(/[^a-z0-9]+/gi, "_")
+    .replace(/^_+|_+$/g, "")
+    .toUpperCase();
+  return Array.from(new Set([
+    token,
+    token ? `${token}_API_KEY` : "",
+    token ? `${token}_TOKEN` : ""
+  ].filter(Boolean)));
+}
+
+function readServerSecret(authRef) {
+  for (const key of envKeyCandidates(authRef)) {
+    if (process.env[key]) return { key, value: process.env[key] };
+  }
+  return null;
+}
+
+function buildAuthHeaders(record, secretValue) {
+  if (!secretValue) return {};
+  const meta = record?.requestHeadersMetadata || {};
+  const headerName = String(meta.authHeaderName || record?.authHeaderName || record?.authHeader || "x-api-key").trim();
+  if (!headerName) return {};
+  const prefix = String(meta.authPrefix || record?.authPrefix || "").trim();
+  return { [headerName]: prefix ? `${prefix} ${secretValue}` : secretValue };
+}
+
+function findRegistryRecord(workspaceConfig, registryId) {
+  const id = String(registryId || "").trim();
+  if (!id) return null;
+  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  for (const objectItem of objects) {
+    if (objectItem?.objectType !== "api-registry") continue;
+    const rows = Array.isArray(objectItem.rows) ? objectItem.rows : [];
+    const match = rows.find(
+      (r) => String(r?.integrationId || "").trim() === id
+        || String(r?.id || "").trim() === id
+        || String(r?.Name || "").trim() === id
+    );
+    if (match) return match;
+  }
+  return null;
+}
+
+function parseInputPayload(inputNode) {
+  const config = inputNode?.config || {};
+  const mode = String(config.inputMode || "manual").trim();
+  if (mode === "manual") {
+    const sample = config.samplePayload;
+    if (sample && typeof sample === "object") return sample;
+    if (typeof sample === "string" && sample.trim()) {
+      try {
+        return JSON.parse(sample);
+      } catch {
+        return {};
+      }
+    }
+    return {};
+  }
+  return {};
+}
+
+function transformProviderPayload(rawPayload, transformConfig) {
+  const config = transformConfig || {};
+  const rootPath = String(config.rootPath || "").trim();
+  let cursor = rootPath ? getValueAtPath(rawPayload, rootPath) : rawPayload;
+  if (cursor === undefined) cursor = rawPayload;
+
+  const fieldMap = config.fieldMap && typeof config.fieldMap === "object" ? config.fieldMap : {};
+  if (Object.keys(fieldMap).length) {
+    if (Array.isArray(cursor)) {
+      cursor = cursor.map((row) => applyFieldMap(row, fieldMap));
+    } else if (cursor && typeof cursor === "object") {
+      cursor = applyFieldMap(cursor, fieldMap);
+    }
+  }
+
+  if (Array.isArray(cursor)) {
+    const filtered = applyFilters(cursor, config.filters, config.filterMode);
+    const maxRows = Number(config.maxRows);
+    if (Number.isFinite(maxRows) && maxRows > 0) {
+      return filtered.slice(0, maxRows);
+    }
+    return filtered;
+  }
+
+  return cursor;
+}
+
+function getValueAtPath(obj, path) {
+  if (!path) return obj;
+  const parts = String(path).split(".").filter(Boolean);
+  let cursor = obj;
+  for (const part of parts) {
+    if (cursor == null || typeof cursor !== "object") return undefined;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+
+async function executeApiRegistryCall(workspaceConfig, nodeConfig, inputPayload, timeoutMs) {
+  const registryId = String(nodeConfig?.registryId || nodeConfig?.integrationId || "").trim();
+  const registryRecord = findRegistryRecord(workspaceConfig, registryId);
+  if (!registryRecord) {
+    return {
+      ok: false,
+      exitCode: 1,
+      durationMs: 0,
+      stdout: "",
+      stderr: "",
+      error: `no API Registry row for integrationId ${registryId}`,
+      adapterMeta: { mode: "orchestration-graph", registryId }
+    };
+  }
+
+  const merged = {
+    ...registryRecord,
+    method: nodeConfig?.method || registryRecord.method,
+    endpoint: nodeConfig?.endpoint || registryRecord.endpoint,
+    baseUrl: nodeConfig?.baseUrl || registryRecord.baseUrl,
+    authRef: nodeConfig?.authRef || registryRecord.authRef || registryId,
+    requestHeadersMetadata: {
+      ...(registryRecord.requestHeadersMetadata || {}),
+      ...(nodeConfig?.requestHeadersMetadata || {})
+    },
+    authHeaderName: nodeConfig?.requestHeadersMetadata?.authHeaderName
+      || registryRecord.authHeaderName
+      || registryRecord.authHeader,
+    authPrefix: nodeConfig?.requestHeadersMetadata?.authPrefix || registryRecord.authPrefix
+  };
+
+  let url;
+  try {
+    url = buildUrl(merged, inputPayload);
+  } catch (err) {
+    return {
+      ok: false,
+      exitCode: 1,
+      durationMs: 0,
+      stdout: "",
+      stderr: "",
+      error: err.message || "invalid URL",
+      adapterMeta: { mode: "orchestration-graph", registryId }
+    };
+  }
+
+  const method = normalizeMethod(merged.method);
+  const authRef = merged.authRef || registryId;
+  const secretEntry = readServerSecret(authRef);
+  const secret = secretEntry?.value || "";
+  const outboundTimeout = Math.min(Math.max(timeoutMs, 1000), 120000);
+  const startedAt = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), outboundTimeout);
+
+  const meta = nodeConfig?.requestHeadersMetadata || {};
+  const contentType = String(meta.contentType || "").trim() || (method === "GET" ? "" : "application/json");
+
+  let body;
+  const bodyTemplate = substituteVariables(String(nodeConfig?.bodyTemplate || ""), inputPayload);
+  if (method !== "GET" && bodyTemplate) {
+    try {
+      body = JSON.parse(bodyTemplate);
+    } catch {
+      body = bodyTemplate;
+    }
+  }
+
+  try {
+    const response = await fetch(url, {
+      method,
+      headers: {
+        accept: "application/json, text/plain;q=0.9,*/*;q=0.8",
+        ...(contentType ? { "content-type": contentType } : {}),
+        ...buildAuthHeaders(merged, secret)
+      },
+      ...(body !== undefined ? { body: typeof body === "string" ? body : JSON.stringify(body) } : {}),
+      signal: controller.signal
+    });
+    const durationMs = Date.now() - startedAt;
+    const responseContentType = response.headers.get("content-type") || "";
+    const payload = responseContentType.includes("application/json") ? await response.json() : await response.text();
+
+    return {
+      ok: response.ok,
+      exitCode: response.ok ? 0 : 1,
+      durationMs,
+      stdout: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2),
+      stderr: "",
+      error: response.ok ? undefined : `HTTP ${response.status}`,
+      rawPayload: payload,
+      httpStatus: response.status,
+      adapterMeta: {
+        mode: "orchestration-graph",
+        registryId,
+        url,
+        httpStatus: response.status,
+        method,
+        authRefSlug: authRef
+      }
+    };
+  } catch (error) {
+    const durationMs = Date.now() - startedAt;
+    const safeError = redactSecretsFromText(
+      error.name === "AbortError" ? `request timed out after ${outboundTimeout}ms` : (error.message || "fetch failed")
+    );
+    return {
+      ok: false,
+      exitCode: null,
+      durationMs,
+      stdout: "",
+      stderr: "",
+      error: safeError,
+      adapterMeta: { mode: "orchestration-graph", registryId, url, aborted: error.name === "AbortError" }
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Run a growthub-native orchestration graph when present on the sandbox row.
+ * Returns null when the row has no executable graph (caller falls back to adapter path).
+ */
+async function runOrchestrationGraphIfPresent({ workspaceConfig, row, timeoutMs }) {
+  const graph = parseOrchestrationGraph(row?.orchestrationGraph || row?.orchestrationConfig);
+  if (!graph || String(graph.provider || "").trim() !== "growthub-native") return null;
+
+  const apiNode = extractApiRegistryCallNode(graph);
+  if (!apiNode?.config) {
+    return {
+      ok: false,
+      exitCode: 1,
+      durationMs: 0,
+      stdout: "",
+      stderr: "",
+      error: "orchestrationGraph is missing an api-registry-call node",
+      adapterMeta: { mode: "orchestration-graph", provider: graph.provider }
+    };
+  }
+
+  const inputNode = extractInputNode(graph);
+  const inputPayload = parseInputPayload(inputNode);
+  const transformConfig = extractTransformConfig(graph);
+  const resultNode = graph.nodes?.find((n) => n?.type === "tool-result");
+  const successCodes = Array.isArray(resultNode?.config?.successStatusCodes)
+    ? resultNode.config.successStatusCodes.map(Number).filter(Number.isFinite)
+    : [200];
+
+  const raw = await executeApiRegistryCall(
+    workspaceConfig,
+    apiNode.config,
+    inputPayload,
+    Number(apiNode.config?.timeoutMs) || timeoutMs
+  );
+
+  if (raw.ok && raw.rawPayload !== undefined) {
+    const httpStatus = Number(raw.httpStatus);
+    if (successCodes.length && !successCodes.includes(httpStatus)) {
+      raw.ok = false;
+      raw.exitCode = 1;
+      raw.error = `HTTP ${httpStatus} is not in successStatusCodes`;
+    }
+    const transformed = transformProviderPayload(raw.rawPayload, transformConfig);
+    raw.stdout = typeof transformed === "string"
+      ? transformed
+      : normalizeJsonAtPath(transformed, "");
+    delete raw.rawPayload;
+    delete raw.httpStatus;
+  } else if (raw.error) {
+    raw.error = redactSecretsFromText(raw.error);
+  }
+
+  if (raw.stdout) {
+    raw.stdout = redactSecretsFromText(raw.stdout);
+  }
+
+  return {
+    ...raw,
+    adapterMeta: {
+      ...(raw.adapterMeta || {}),
+      orchestrationProvider: graph.provider,
+      orchestrationVersion: graph.version
+    }
+  };
+}
+
+export { runOrchestrationGraphIfPresent };