@growthub/cli 0.13.4 → 0.13.5

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

@@ -8,12 +8,14 @@ import {
   extractApiRegistryCallNode,
   extractInputNode,
   extractTransformConfig,
+  isAgentSwarmGraph,
   normalizeJsonAtPath,
   parseOrchestrationGraph,
   redactSecretsFromText,
   substituteVariables
 } from "./orchestration-graph.js";
 import { buildInputPayloadForRunner } from "./orchestration-run-inputs.js";
+import { runAgentSwarmGraphIfPresent } from "./orchestration-agent-swarm.js";
 
 function normalizeMethod(value) {
   const method = String(value || "GET").trim().toUpperCase();
@@ -262,10 +264,21 @@ async function executeApiRegistryCall(workspaceConfig, nodeConfig, inputPayload,
  * for `human-input` / form workflows. Secret values (those stored as
  * `{ secretRef }`) are never expanded into the runner payload.
  */
-async function runOrchestrationGraphIfPresent({ workspaceConfig, row, timeoutMs, runInputs }) {
+async function runOrchestrationGraphIfPresent({ workspaceConfig, row, timeoutMs, runInputs, executionContext }) {
   const graph = parseOrchestrationGraph(row?.orchestrationGraph || row?.orchestrationConfig);
   if (!graph || String(graph.provider || "").trim() !== "growthub-native") return null;
 
+  if (isAgentSwarmGraph(graph)) {
+    return await runAgentSwarmGraphIfPresent({
+      workspaceConfig,
+      row,
+      graph,
+      timeoutMs,
+      runInputs,
+      executionContext
+    });
+  }
+
   const apiNode = extractApiRegistryCallNode(graph);
   if (!apiNode?.config) {
     return {

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

@@ -151,11 +151,16 @@ function validateOrchestrationGraph(graph) {
         errors.push(`${prefix}.type "${type}" is not a known node type`);
       }
     });
-    const hasThinAdapter = graph.nodes.some((n) => n?.type === "thinAdapter");
-    const hasApi = graph.nodes.some((n) => n?.type === "api-registry-call");
-    const hasResult = graph.nodes.some((n) => n?.type === "tool-result");
-    if (!hasThinAdapter && !hasApi) errors.push("orchestrationGraph requires an api-registry-call node");
-    if (!hasThinAdapter && !hasResult) errors.push("orchestrationGraph requires a tool-result node");
+    if (isAgentSwarmGraph(graph)) {
+      const swarmCheck = validateAgentSwarmGraph(graph);
+      if (!swarmCheck.ok) errors.push(...swarmCheck.errors);
+    } else {
+      const hasThinAdapter = graph.nodes.some((n) => n?.type === "thinAdapter");
+      const hasApi = graph.nodes.some((n) => n?.type === "api-registry-call");
+      const hasResult = graph.nodes.some((n) => n?.type === "tool-result");
+      if (!hasThinAdapter && !hasApi) errors.push("orchestrationGraph requires an api-registry-call node");
+      if (!hasThinAdapter && !hasResult) errors.push("orchestrationGraph requires a tool-result node");
+    }
   }
   if (!Array.isArray(graph.edges)) {
     errors.push("orchestrationGraph.edges must be an array");
@@ -680,6 +685,207 @@ function addCanonicalNodeToGraph(graph, nodeId, registryRow, options = {}) {
   return { ...parsed, nodes, edges };
 }
 
+const AGENT_SWARM_EXECUTION_MODE = "agent-swarm-v1";
+
+/**
+ * Detect whether a graph is an agent-swarm-v1 control plane. Swarm graphs are
+ * encoded as growthub-native graphs whose root carries
+ * `executionMode: "agent-swarm-v1"` and that contain at least one orchestrator
+ * (`thinAdapter`) or subagent (`ai-agent`) node.
+ */
+function isAgentSwarmGraph(graph) {
+  const parsed = parseOrchestrationGraph(graph) || graph;
+  if (!parsed || typeof parsed !== "object") return false;
+  if (String(parsed.provider || "").trim() !== "growthub-native") return false;
+  if (String(parsed.executionMode || "").trim() !== AGENT_SWARM_EXECUTION_MODE) return false;
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  if (!nodes.length) return false;
+  return nodes.some((n) => n?.type === "thinAdapter" || n?.type === "ai-agent");
+}
+
+/**
+ * Split a swarm graph into its semantic parts so the runtime and UI can reason
+ * about it without re-walking the node list. Returns `null` when the graph is
+ * not a recognized swarm.
+ */
+function extractSwarmNodes(graph) {
+  const parsed = parseOrchestrationGraph(graph) || graph;
+  if (!isAgentSwarmGraph(parsed)) return null;
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  const orchestrator = nodes.find((n) => n?.type === "thinAdapter") || null;
+  const subagents = nodes.filter((n) => n?.type === "ai-agent");
+  const synthesis = nodes.find((n) => n?.type === "tool-result") || null;
+  const humanInputs = nodes.filter((n) => n?.type === "human-input");
+  const flowControls = nodes.filter((n) => n?.type === "flow-control");
+  const swarmConfig = (parsed.swarm && typeof parsed.swarm === "object" && !Array.isArray(parsed.swarm))
+    ? parsed.swarm
+    : {};
+  return {
+    graph: parsed,
+    orchestrator,
+    subagents,
+    synthesis,
+    humanInputs,
+    flowControls,
+    swarmConfig
+  };
+}
+
+/**
+ * Build the default scaffold for a new agent-swarm-v1 graph. The shape mirrors
+ * the Kimi screenshots — an orchestrator, two specialized subagents, a
+ * synthesis tool-result — but reuses existing node types so no schema change
+ * is required.
+ */
+function buildDefaultAgentSwarmGraph(options = {}) {
+  const agentHost = String(options.agentHost || "").trim();
+  const subagents = Array.isArray(options.subagents) && options.subagents.length > 0
+    ? options.subagents
+    : [
+        {
+          id: "subagent-researcher",
+          role: "Researcher",
+          description: "Gathers facts from the run input and the orchestrator's plan.",
+          taskPrompt: "Investigate the orchestrator's plan and gather the relevant facts.",
+          tools: ["read", "summarize"],
+          required: true
+        },
+        {
+          id: "subagent-analyst",
+          role: "Analyst",
+          description: "Stress-tests assumptions and surfaces risks.",
+          taskPrompt: "Identify risks, assumptions, and dependencies in the orchestrator's plan.",
+          tools: ["read", "critique"],
+          required: true
+        }
+      ];
+
+  const nodes = [
+    {
+      id: "orchestrator",
+      type: "thinAdapter",
+      label: "Orchestrator",
+      subtitle: "Plans subagent dispatch",
+      sandbox: "orchestrator",
+      config: {
+        executionPolicy: "parallel",
+        prompt: String(options.orchestratorPrompt || "Decompose the task into independent subtasks for the listed subagents.").trim(),
+        inputBinding: "{{input.payload}}",
+        outputKey: "plan"
+      }
+    },
+    ...subagents.map((agent) => ({
+      id: String(agent.id || agent.role || "subagent").replace(/[^a-zA-Z0-9_-]+/g, "-"),
+      type: "ai-agent",
+      label: String(agent.role || agent.id || "Subagent"),
+      subtitle: "Swarm subagent",
+      config: {
+        role: String(agent.role || agent.id || "Subagent"),
+        description: String(agent.description || "").trim(),
+        taskPrompt: String(agent.taskPrompt || "").trim(),
+        tools: Array.isArray(agent.tools) ? agent.tools.map((t) => String(t || "").trim()).filter(Boolean) : [],
+        agentHost: String(agent.agentHost || agentHost || "").trim(),
+        adapter: String(agent.adapter || "").trim(),
+        required: agent.required !== false,
+        canReadWorkspace: true,
+        canWriteDraft: false,
+        networkAccess: agent.networkAccess === true,
+        maxTokens: Number.isFinite(Number(agent.maxTokens)) && Number(agent.maxTokens) > 0
+          ? Math.floor(Number(agent.maxTokens))
+          : 0,
+        timeoutMs: Number.isFinite(Number(agent.timeoutMs)) && Number(agent.timeoutMs) > 0
+          ? Math.floor(Number(agent.timeoutMs))
+          : 0
+      }
+    })),
+    {
+      id: "synthesis",
+      type: "tool-result",
+      label: "Final synthesis",
+      subtitle: "Aggregate subagent results",
+      config: {
+        successStatusCodes: [200],
+        writeLastResponse: true,
+        writeSourceRecord: true,
+        outputMode: "swarm-summary",
+        statusField: "status",
+        lastTestedField: "lastTested",
+        outcomePrompt: String(options.outcomePrompt || "Confirm every required subagent completed and write the final answer.").trim()
+      }
+    }
+  ];
+
+  const edges = [
+    ...subagents.map((agent) => ({
+      from: "orchestrator",
+      to: String(agent.id || agent.role || "subagent").replace(/[^a-zA-Z0-9_-]+/g, "-"),
+      passes: "subtask-assignment"
+    })),
+    ...subagents.map((agent) => ({
+      from: String(agent.id || agent.role || "subagent").replace(/[^a-zA-Z0-9_-]+/g, "-"),
+      to: "synthesis",
+      passes: "subtask-result"
+    }))
+  ];
+
+  const maxConcurrency = Math.max(1, Number(options.maxConcurrency) || subagents.length);
+  const rewardWeights = options.rewardWeights && typeof options.rewardWeights === "object"
+    ? options.rewardWeights
+    : { parallel: 0.25, finish: 0.35, outcome: 0.4 };
+
+  return {
+    version: 1,
+    provider: "growthub-native",
+    executionMode: AGENT_SWARM_EXECUTION_MODE,
+    swarm: {
+      maxConcurrency,
+      rewardWeights: {
+        parallel: Number(rewardWeights.parallel) || 0,
+        finish: Number(rewardWeights.finish) || 0,
+        outcome: Number(rewardWeights.outcome) || 0
+      },
+      outcomeCriteria: String(options.outcomeCriteria || "All required subagents complete and synthesis runs without error.").trim()
+    },
+    nodes,
+    edges
+  };
+}
+
+/**
+ * Schema-aware validation for agent-swarm-v1 graphs. Returns `{ ok, errors }`
+ * with concrete user-facing messages. Used both by validateOrchestrationGraph
+ * and the WorkflowSurface Test gate so the user never gets a runtime "swarm
+ * subagent has no prompt-capable adapter" error at Test time when the static
+ * config already revealed the issue.
+ */
+function validateAgentSwarmGraph(graph) {
+  const errors = [];
+  if (!graph || typeof graph !== "object") {
+    return { ok: false, errors: ["agent-swarm graph must be an object"] };
+  }
+  const extracted = extractSwarmNodes(graph);
+  if (!extracted) return { ok: false, errors: ["graph is not an agent-swarm-v1 graph"] };
+  const { orchestrator, subagents, synthesis } = extracted;
+  if (!orchestrator) errors.push("missing orchestrator (thinAdapter) node");
+  if (subagents.length === 0) errors.push("agent-swarm requires at least one ai-agent subagent");
+  subagents.forEach((node, index) => {
+    const cfg = node?.config || {};
+    const role = String(cfg.role || node?.label || "").trim();
+    if (!role) errors.push(`subagent[${index}] (${node?.id || "?"}) must declare a role`);
+    if (!String(cfg.taskPrompt || cfg.prompt || "").trim()) {
+      errors.push(`subagent "${role || node?.id}" must declare a task prompt`);
+    }
+    const adapter = String(cfg.adapter || "").trim();
+    if (adapter && !["local-agent-host", "local-intelligence"].includes(adapter)) {
+      errors.push(`subagent "${role || node?.id}" sets adapter="${adapter}" which cannot execute prompts; use local-agent-host or local-intelligence`);
+    }
+  });
+  if (!synthesis) {
+    errors.push("agent-swarm graph should include a tool-result synthesis node to evaluate outcome");
+  }
+  return { ok: errors.length === 0, errors };
+}
+
 function redactSecretsFromText(text) {
   let out = String(text || "");
   for (const pattern of [
@@ -699,9 +905,14 @@ export {
   FILTER_OPERATORS,
   FILTER_CONJUNCTIONS,
   CANONICAL_NODE_ORDER,
+  AGENT_SWARM_EXECUTION_MODE,
   buildBlankOrchestrationGraphShell,
   buildDefaultOrchestrationGraphFromRegistry,
+  buildDefaultAgentSwarmGraph,
   buildCanonicalNode,
+  isAgentSwarmGraph,
+  extractSwarmNodes,
+  validateAgentSwarmGraph,
   isOrchestrationGraphEmpty,
   getOrchestrationGraphUiState,
   getNextCanonicalNodeId,

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

@@ -160,6 +160,9 @@ function buildLogChildren(record, summary) {
 
 function buildRunLogTree(record) {
   if (!record || typeof record !== "object") return [];
+  if (Array.isArray(record.logTree) && record.logTree.length > 0) {
+    return record.logTree;
+  }
   const summary = deriveRunSummary(record);
   const durationMs = clampNumber(record?.durationMs) || 0;
   const attemptChildren = buildLogChildren(record, summary);
@@ -224,6 +227,29 @@ function normalizeRunConsoleRecord(record) {
   const safeInput = rawInput ? redactRunInputsEnvelope(rawInput) : null;
   const inputSummary = safeInput ? summarizeRunInputs(safeInput) : null;
   const exports = buildExportsForRecord(record, stdoutText, stderrText, outputText);
+  // Workspace Metadata Graph V1 — safe lineage projection. Names only,
+  // no secrets. Lets the Live Runs Console UI render "this run came from
+  // sandbox X / workflow Y / adapter Z / agent host A" without re-deriving
+  // the relationships from raw fields.
+  const lineage = {
+    runId: safeString(record.runId).trim(),
+    objectId: safeString(record.objectId).trim(),
+    sandboxName: safeString(record.name || record.sandboxName).trim(),
+    workflowRowId: safeString(record.name || record.sandboxName).trim(),
+    workflowMetadataId: safeString(record.objectId).trim() && safeString(record.name || record.sandboxName).trim()
+      ? `workflow:${safeString(record.objectId).trim()}:${safeString(record.name || record.sandboxName).trim()}`
+      : "",
+    sandboxMetadataId: safeString(record.objectId).trim() && safeString(record.name || record.sandboxName).trim()
+      ? `sandbox:${safeString(record.objectId).trim()}:${safeString(record.name || record.sandboxName).trim()}`
+      : "",
+    adapter: safeString(record.adapter).trim(),
+    agentHost: safeString(record.agentHost).trim(),
+    runtime: safeString(record.runtime).trim(),
+    runLocality: safeString(record.runLocality).trim(),
+    inputFieldCount: inputSummary ? inputSummary.fieldCount : 0,
+    inputSource: inputSummary ? inputSummary.source : "",
+    hasOutput: Boolean(outputText)
+  };
 
   return {
     runId: safeString(record.runId).trim(),
@@ -275,6 +301,8 @@ function normalizeRunConsoleRecord(record) {
       adapterMeta,
       templateTrace
     },
+    lineage,
+    swarm: record.swarm && typeof record.swarm === "object" ? record.swarm : null,
     logTree: buildRunLogTree(record)
   };
 }

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

@@ -307,6 +307,48 @@ function buildInputPayloadForRunner(envelope) {
   return out;
 }
 
+/**
+ * Workspace Metadata Graph V1 — typed run-input descriptors.
+ *
+ * Returns a metadata-compatible list:
+ *   { id, label, type, required, secretRefOnly, sourceNodeId, workflowId }
+ *
+ * Used by the metadata store + workflow sidecar so the manual run input
+ * schema is a single typed contract — never re-derived inside UI code.
+ *
+ * Existing redaction + size limits remain enforced by
+ * `validateRunInputsEnvelope` / `normalizeRunInputsEnvelope`. This helper
+ * is descriptor-only and does not mutate or echo any field value.
+ */
+function describeRunInputMetadataItems({ workflowId, graph, objectId, rowId } = {}) {
+  const schema = discoverRunInputSchema(graph);
+  const fields = Array.isArray(schema?.fields) ? schema.fields : [];
+  const workflowKey = String(workflowId || (objectId && rowId ? `${objectId}::${rowId}` : "")).trim();
+  const sourceNodeId = findFirstHumanInputNodeId(graph);
+  return fields.map((field) => ({
+    kind: "workspaceRunInput",
+    id: field.id,
+    label: field.label,
+    type: field.type,
+    required: Boolean(field.required),
+    isSecret: Boolean(field.isSecret),
+    secretRefOnly: Boolean(field.isSecret) || field.type === "secretRef",
+    sourceNodeId,
+    workflowId: workflowKey
+  }));
+}
+
+function findFirstHumanInputNodeId(graphValue) {
+  const graph = parseOrchestrationGraph(graphValue) || graphValue || null;
+  const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  for (const node of nodes) {
+    const type = String(node?.type || "").trim();
+    const action = String(node?.config?.action || "").trim();
+    if (type === "human-input" || action === "form") return String(node?.id || "").trim() || "human-input";
+  }
+  return "";
+}
+
 export {
   RUN_INPUTS_KIND,
   MAX_RUN_INPUT_VALUES,
@@ -319,5 +361,6 @@ export {
   summarizeRunInputs,
   validateRunInputsEnvelope,
   buildInputPayloadForRunner,
+  describeRunInputMetadataItems,
   parseFieldDescriptor
 };

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

@@ -60,7 +60,9 @@ function parseSandboxRunTrace(lastResponse) {
     envRefsMissing: Array.isArray(parsed.envRefsMissing) ? parsed.envRefsMissing : [],
     input: safeInput,
     inputSummary: safeInput ? summarizeRunInputs(safeInput) : null,
-    exports: parsed.exports && typeof parsed.exports === "object" ? parsed.exports : null
+    exports: parsed.exports && typeof parsed.exports === "object" ? parsed.exports : null,
+    swarm: parsed.swarm && typeof parsed.swarm === "object" ? parsed.swarm : null,
+    logTree: Array.isArray(parsed.logTree) ? parsed.logTree : null
   };
 }
 

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/sandbox-agent-auth.js

@@ -585,6 +585,41 @@ function notFoundError(message) {
   return error;
 }
 
+// ──────────────────────────────────────────────────────────────────────────
+// Workspace Metadata Graph V1 — safe agent host readiness metadata.
+//
+// Pure helper that distills a sandbox row into the safe metadata the
+// workspace metadata graph + UI inspector can show. Reads ONLY the safe,
+// allowlisted readiness fields the auth helper persists on the row. Never
+// echoes raw tokens, login URLs, or stdout/stderr — those live inside the
+// helper's response object, not the row patch.
+// ──────────────────────────────────────────────────────────────────────────
+
+function describeAgentHostReadinessMetadata(row) {
+  if (!row || typeof row !== "object") return null;
+  const adapter = String(row?.adapter || "").trim();
+  const agentHost = String(row?.agentHost || "").trim();
+  const runLocality = String(row?.runLocality || "").trim();
+  const safe = {};
+  for (const key of SAFE_ROW_PATCH_FIELDS) {
+    if (Object.prototype.hasOwnProperty.call(row, key)) {
+      safe[key] = row[key];
+    }
+  }
+  return {
+    kind: "workspaceAgentHostReadiness",
+    adapter,
+    agentHost,
+    runLocality,
+    status: KNOWN_AGENT_AUTH_STATUSES.includes(safe.agentAuthStatus) ? safe.agentAuthStatus : "unknown",
+    provider: String(safe.agentAuthProvider || agentHost || "unknown").trim(),
+    lastChecked: String(safe.agentAuthLastChecked || "").trim(),
+    lastExitCode: typeof safe.agentAuthLastExitCode === "number" ? safe.agentAuthLastExitCode : null,
+    lastMessage: String(safe.agentAuthLastMessage || "").trim(),
+    lastLoginUrl: String(safe.agentAuthLastLoginUrl || "").trim()
+  };
+}
+
 // ──────────────────────────────────────────────────────────────────────────
 // Backwards-compatible Claude aliases (legacy)
 // ──────────────────────────────────────────────────────────────────────────
@@ -616,6 +651,7 @@ export {
   buildRowPatch,
   checkAgentStatus,
   checkClaudeStatus,
+  describeAgentHostReadinessMetadata,
   findSandboxRow,
   getAgentHostCapabilities,
   redactSecrets,

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-chart-values.js

@@ -529,6 +529,58 @@ function deriveChartHydrationState({
   return "computed";
 }
 
+/**
+ * Workspace Metadata Graph V1 — typed widget dependency contract.
+ *
+ * Returns the same dependency shape Twenty-style sidecars consume: required
+ * axis fields, filter fields, sort fields, aggregation fields, output shape,
+ * and per-widget warnings. The metadata store calls a richer derivation that
+ * carries the bound object id; this helper accepts a single widget config
+ * and returns the dependency contract without needing the full store.
+ *
+ * Pure. No fetch. No mutation. Never throws on partial widget shapes.
+ */
+function deriveWidgetDependencyContract(widget) {
+  const config = isPlainObject(widget?.config) ? widget.config : {};
+  const binding = isPlainObject(config.binding) ? config.binding : null;
+  const xAxis = isPlainObject(config.xAxis) ? config.xAxis : null;
+  const yAxis = isPlainObject(config.yAxis) ? config.yAxis : null;
+  const filter = isPlainObject(config.filter) ? config.filter : null;
+  const xField = typeof xAxis?.field === "string" ? xAxis.field.trim() : "";
+  const yField = typeof yAxis?.field === "string" ? yAxis.field.trim() : "";
+  const groupField = typeof yAxis?.groupBy === "string" ? yAxis.groupBy.trim() : "";
+  const operation = typeof yAxis?.operation === "string"
+    ? yAxis.operation.trim()
+    : (typeof yAxis?.aggregation === "string" ? yAxis.aggregation.trim() : "sum");
+  const clauses = Array.isArray(filter?.clauses) ? filter.clauses : [];
+  const filterFields = [];
+  for (const clause of clauses) {
+    if (!isPlainObject(clause)) continue;
+    const field = typeof clause.fieldId === "string" ? clause.fieldId.trim() : "";
+    if (field && !filterFields.includes(field)) filterFields.push(field);
+  }
+  const sortFields = xField ? [xField] : [];
+  const aggregationFields = yField ? [yField] : [];
+  const required = Array.from(new Set([xField, yField, groupField].filter(Boolean)));
+  const widgetKind = typeof widget?.kind === "string" ? widget.kind.trim() : "chart";
+  const warnings = [];
+  if (widgetKind === "chart" && required.length === 0 && operation !== "count" && operation !== "countAll") {
+    warnings.push("Chart widget is missing both X and Y axis fields.");
+  }
+  return {
+    objectId: typeof binding?.objectId === "string" ? binding.objectId.trim() : "",
+    sourceType: typeof binding?.sourceType === "string" ? binding.sourceType.trim() : "",
+    sourceAuthority: "workspace-config",
+    required,
+    filter: filterFields,
+    sort: sortFields,
+    aggregation: aggregationFields,
+    operation: operation || "sum",
+    outputShape: widgetKind === "chart" ? "number[]" : "row[]",
+    warnings
+  };
+}
+
 export {
   KNOWN_AGGREGATIONS,
   applyFilter,
@@ -538,5 +590,6 @@ export {
   computeChartProjectionDebug,
   computeChartValuesFromRows,
   deriveChartHydrationState,
+  deriveWidgetDependencyContract,
   groupRows
 };