@growthub/cli 0.14.2 → 0.14.4

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

@@ -44,6 +44,11 @@ import {
   validateOrchestrationGraph
 } from "@/lib/orchestration-graph";
 import { resolveConnectorAction } from "@/lib/orchestration-sidecar-routing";
+import {
+  nodeSandboxRecordRef,
+  patchSandboxRowInConfig,
+  withGraphSandboxRecordRefs
+} from "@/lib/orchestration-publish";
 import { OrchestrationGraphCanvas } from "../data-model/components/OrchestrationGraphCanvas.jsx";
 import { OrchestrationGraphEmptyCanvas } from "../data-model/components/OrchestrationGraphEmptyCanvas.jsx";
 import { OrchestrationNodeConfigPanel } from "../data-model/components/OrchestrationNodeConfigPanel.jsx";
@@ -117,47 +122,6 @@ function resolveRegistryRefForSandbox(workspaceConfig, sandboxRow) {
   return firstRegistryRow ? { object: firstRegistryObject, row: firstRegistryRow } : null;
 }
 
-function patchSandboxRowInConfig(workspaceConfig, objectId, rowIndex, fields) {
-  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
-  return {
-    ...workspaceConfig,
-    dataModel: {
-      ...workspaceConfig.dataModel,
-      objects: objects.map((object) => {
-        if (object?.id !== objectId) return object;
-        const rows = Array.isArray(object.rows) ? object.rows : [];
-        return {
-          ...object,
-          rows: rows.map((row, index) => (index === rowIndex ? { ...row, ...fields } : row)),
-        };
-      }),
-    },
-  };
-}
-
-function nodeSandboxRecordRef(objectId, rowName, nodeId) {
-  return {
-    objectId: String(objectId || "").trim(),
-    rowName: String(rowName || "").trim(),
-    nodeId: String(nodeId || "").trim()
-  };
-}
-
-function withGraphSandboxRecordRefs(graph, objectId, rowName) {
-  const parsed = parseOrchestrationGraph(graph) || graph;
-  if (!parsed || typeof parsed !== "object") return parsed;
-  return {
-    ...parsed,
-    nodes: (Array.isArray(parsed.nodes) ? parsed.nodes : []).map((node) => ({
-      ...node,
-      config: {
-        ...(node?.config || {}),
-        sandboxRecordRef: nodeSandboxRecordRef(objectId, rowName, node?.id)
-      }
-    }))
-  };
-}
-
 const WORKFLOW_ACTION_GROUPS = [
   {
     label: "Data",
@@ -201,90 +165,6 @@ function getWorkspaceObjectOptions(workspaceConfig) {
     }));
 }
 
-function normalizeDeltaTags(tags) {
-  return Array.from(new Set((Array.isArray(tags) ? tags : [])
-    .map((tag) => String(tag || "").trim().toLowerCase())
-    .filter(Boolean)));
-}
-
-function inferDeltaTagsForWorkflowNode(node, config) {
-  const tags = [];
-  const type = String(node?.type || "").trim();
-  const action = String(config?.action || node?.id || "").trim();
-  if (type === "thinAdapter") tags.push("model", "prompt", "routing");
-  if (type === "ai-agent") tags.push("model", "prompt", "output");
-  if (type === "data-action" || type === "data-trigger") tags.push("input", "output");
-  if (type === "flow-control") tags.push("routing");
-  if (type === "core-action") tags.push("runtime");
-  if (type === "human-input") tags.push("input");
-  if (action.includes("search") || action.includes("filter")) tags.push("evaluation", "guardrail");
-  if (action.includes("delete") || config?.confirmationRequired) tags.push("guardrail");
-  if (action.includes("http") || config?.url || config?.method) tags.push("routing", "input", "output");
-  if (action.includes("email")) tags.push("input", "output");
-  if (action.includes("delay") || config?.duration || config?.unit) tags.push("runtime");
-  if (config?.objectId || config?.fieldMap || config?.filters) tags.push("input", "output");
-  if (config?.model || config?.prompt) tags.push("model", "prompt");
-  return normalizeDeltaTags(tags);
-}
-
-function getNodeDeltaRecords(previousGraph, nextGraph) {
-  const previousNodes = new Map(
-    (Array.isArray(previousGraph?.nodes) ? previousGraph.nodes : [])
-      .map((node) => [String(node?.id || ""), node])
-      .filter(([id]) => id)
-  );
-
-  return (Array.isArray(nextGraph?.nodes) ? nextGraph.nodes : [])
-    .map((node) => {
-      const nodeId = String(node?.id || "").trim();
-      if (!nodeId) return null;
-      const previous = previousNodes.get(nodeId);
-      const config = node?.config && typeof node.config === "object" && !Array.isArray(node.config) ? node.config : {};
-      const previousConfig = previous?.config && typeof previous.config === "object" && !Array.isArray(previous.config)
-        ? previous.config
-        : {};
-      const currentComparable = JSON.stringify({
-        type: node?.type || "",
-        sandbox: node?.sandbox || "",
-        label: node?.label || "",
-        subtitle: node?.subtitle || "",
-        config
-      });
-      const previousComparable = JSON.stringify({
-        type: previous?.type || "",
-        sandbox: previous?.sandbox || "",
-        label: previous?.label || "",
-        subtitle: previous?.subtitle || "",
-        config: previousConfig
-      });
-      const explicitTags = normalizeDeltaTags(config.deltaTags);
-      const deltaTags = explicitTags.length > 0 ? explicitTags : inferDeltaTagsForWorkflowNode(node, config);
-      const changeReason = String(config.changeReason || "").trim();
-      const changed = currentComparable !== previousComparable;
-      if (!changed && !changeReason && deltaTags.length === 0) return null;
-      return {
-        nodeId,
-        nodeType: String(node?.type || ""),
-        label: String(node?.label || node?.sandbox || nodeId),
-        sandboxRecordRef: config.sandboxRecordRef || null,
-        changeReason,
-        deltaTags,
-        requiresRetest: config.requiresRetest !== false,
-        previous: previous ? {
-          type: String(previous.type || ""),
-          sandbox: String(previous.sandbox || ""),
-          label: String(previous.label || "")
-        } : null,
-        next: {
-          type: String(node.type || ""),
-          sandbox: String(node.sandbox || ""),
-          label: String(node.label || "")
-        }
-      };
-    })
-    .filter(Boolean);
-}
-
 function makeWorkflowNode(action, workspaceConfig, graph) {
   const baseId = String(action.id || action.type || "step").replace(/[^a-zA-Z0-9_-]+/g, "-");
   const existingIds = new Set((Array.isArray(graph?.nodes) ? graph.nodes : []).map((node) => String(node.id)));
@@ -606,54 +486,31 @@ export default function WorkflowSurface() {
 
   async function publishGraph() {
     if (resolved.rowIndex < 0 || !objectId) return;
+    // Publish is server-authoritative: POST /api/workspace/workflow/publish
+    // verifies the saved draft + passing test against the persisted row and
+    // owns the version bump, delta record, and draft → live promotion.
+    // Direct PATCH of live workflow fields is rejected by the runtime policy.
     const serialized = serializeCurrentGraph();
-    const draftPassed = sandboxRow?.orchestrationDraftTestPassed === true || String(sandboxRow?.orchestrationDraftTestPassed || "") === "true";
-    const testedConfig = String(sandboxRow?.orchestrationDraftTestedConfig || "");
-    if (!draftPassed || testedConfig !== serialized) {
-      setSaveMessage("Publish blocked. Save and test this exact draft successfully before publishing.");
+    const savedDraft = String(sandboxRow?.[draftFieldName] || "");
+    if (dirty || serialized !== savedDraft) {
+      setSaveMessage("Publish blocked. Save this draft first — publish promotes the saved, tested draft.");
       return;
     }
     setPublishing(true);
     setSaveMessage("");
     try {
-      const currentVersion = Number(sandboxRow?.version || 1);
-      const nextVersion = Number.isFinite(currentVersion) ? String(currentVersion + 1) : "1";
-      const previousDeltas = Array.isArray(sandboxRow?.orchestrationDeltas) ? sandboxRow.orchestrationDeltas : [];
-      const previousPublishedGraph = parseOrchestrationGraph(sandboxRow?.[effectiveFieldName]);
-      const graphWithRefs = withGraphSandboxRecordRefs(orchestrationGraph, objectId, rowId);
-      const nodeDeltas = getNodeDeltaRecords(previousPublishedGraph, graphWithRefs);
-      const deltaTags = normalizeDeltaTags(nodeDeltas.flatMap((delta) => delta.deltaTags));
-      const changeReason = nodeDeltas.map((delta) => delta.changeReason).filter(Boolean).join("\n");
-      const next = patchSandboxRowInConfig(workspaceConfig, objectId, resolved.rowIndex, {
-        [effectiveFieldName]: serialized,
-        [draftFieldName]: "",
-        version: nextVersion,
-        lifecycleStatus: "live",
-        orchestrationDraftStatus: "published",
-        orchestrationDraftTestPassed: false,
-        orchestrationDraftTestedConfig: "",
-        orchestrationPublishedAt: new Date().toISOString(),
-        orchestrationDeltas: [
-          ...previousDeltas,
-          {
-            at: new Date().toISOString(),
-            version: nextVersion,
-            field: effectiveFieldName,
-            action: "publish",
-            previousVersion: String(sandboxRow?.version || "1"),
-            draftTestedAt: sandboxRow?.orchestrationDraftLastTested || "",
-            draftRunId: sandboxRow?.orchestrationDraftLastRunId || "",
-            changeReason,
-            deltaTags,
-            nodeDeltas,
-            nodeCount: Array.isArray(orchestrationGraph?.nodes) ? orchestrationGraph.nodes.length : 0,
-            edgeCount: Array.isArray(orchestrationGraph?.edges) ? orchestrationGraph.edges.length : 0
-          }
-        ]
+      const res = await fetch("/api/workspace/workflow/publish", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ objectId, name: rowId, field: effectiveFieldName }),
       });
-      await persistWorkspace(next);
+      const payload = await res.json();
+      if (!res.ok || !payload.ok) {
+        throw new Error(payload.error || "Publish failed");
+      }
+      setWorkspaceConfig(payload.workspaceConfig || workspaceConfig);
       setDirty(false);
-      setSaveMessage(`Published orchestration config v${nextVersion}.`);
+      setSaveMessage(`Published orchestration config v${payload.version}.`);
     } catch (err) {
       setSaveMessage(err.message || "Publish failed");
     } finally {

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

@@ -0,0 +1,211 @@
+/**
+ * CEO Agent Teams — the atomic, reusable team-configuration layer for the /ceo
+ * surface (CEO_PRIMITIVE_COCKPIT_ROADMAP_V1).
+ *
+ * Distinction this module encodes:
+ *   - FLEET (runtime/oversight) = existing `swarm-workflows` rows, readiness,
+ *     run state, failures, receipts, Background Tasks. UNCHANGED by this module.
+ *   - AGENT TEAMS (atomic configuration) = reusable blueprints describing the
+ *     orchestrator, sub-agent roles, skills, processes, workflow
+ *     responsibilities, and outcome criteria of a swarm.
+ *
+ * This is a PURE module — no React, no fetch, no fs, no writes, no localStorage.
+ * It introduces NO new runtime, executor, API route, PATCH allowlist field, or
+ * object type: Agent Teams live in a governed Data Model object of the EXISTING
+ * `custom` objectType, created through the EXISTING `dataModel.object.create`
+ * helper/apply lane, and they only ever *inform* a `/swarm` proposal — the
+ * server still builds the `agent-swarm-v1` graph, the run still lands in
+ * `swarm-workflows`, and execution still happens through `sandbox-run`.
+ *
+ * An Agent Team record never executes anything.
+ */
+
+export const AGENT_SWARM_TEAMS_OBJECT_ID = "agent-swarm-teams";
+export const AGENT_SWARM_TEAMS_LABEL = "Agent Swarm Teams";
+
+// Visible row columns. "Name" is the capital-N identity column (Data Model grid
+// convention). Array-shaped fields are stored as readable strings so we never
+// fight the row-value contract (no typed arrays in rows).
+export const AGENT_SWARM_TEAMS_COLUMNS = [
+  "id",
+  "Name",
+  "status",
+  "teamPurpose",
+  "orchestratorRole",
+  "orchestratorPrompt",
+  "subAgentRoles",
+  "skills",
+  "processes",
+  "workflowResponsibilities",
+  "outcomeCriteria",
+  "defaultRunLocality",
+  "defaultAdapter",
+  "linkedSwarmWorkflowName",
+  "governanceNotes",
+  "createdAt",
+  "updatedAt",
+];
+
+function clean(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function slugify(value) {
+  return clean(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// One clearly-labeled blueprint row so a freshly-created table shows the shape
+// (and is honestly an example, not live state).
+function blueprintRow() {
+  return {
+    id: "team-research-synthesis",
+    Name: "Example — Research & Synthesis Team",
+    status: "blueprint",
+    teamPurpose: "Reusable blueprint: research a topic and synthesize a cited brief.",
+    orchestratorRole: "Research Lead",
+    orchestratorPrompt: "Decompose the objective into independent research subtasks for the team.",
+    subAgentRoles: "Researcher; Analyst; Synthesizer",
+    skills: "web-research; summarization; critique",
+    processes: "gather → analyze → synthesize",
+    workflowResponsibilities: "Researcher gathers facts; Analyst stress-tests; Synthesizer writes the brief",
+    outcomeCriteria: "A cited brief with risks and a clear recommendation",
+    defaultRunLocality: "local",
+    defaultAdapter: "local-intelligence",
+    linkedSwarmWorkflowName: "",
+    governanceNotes: "Blueprint only — launch through /swarm; the run lands in swarm-workflows and emits receipts.",
+    createdAt: "",
+    updatedAt: "",
+  };
+}
+
+/** The governed Agent Teams object definition (existing `custom` objectType). */
+export function buildAgentSwarmTeamsObject({ includeBlueprint = true } = {}) {
+  return {
+    id: AGENT_SWARM_TEAMS_OBJECT_ID,
+    label: AGENT_SWARM_TEAMS_LABEL,
+    objectType: "custom",
+    columns: AGENT_SWARM_TEAMS_COLUMNS.slice(),
+    rows: includeBlueprint ? [blueprintRow()] : [],
+    binding: { mode: "manual", source: AGENT_SWARM_TEAMS_LABEL },
+  };
+}
+
+/**
+ * A governed proposal that CREATES the Agent Teams table through the EXISTING
+ * `dataModel.object.create` helper/apply lane. No new proposal type, no new
+ * objectType — objectType stays `custom`.
+ */
+export function buildCreateAgentTeamsProposal() {
+  return {
+    type: "dataModel.object.create",
+    affectedField: "dataModel",
+    payload: { object: buildAgentSwarmTeamsObject({ includeBlueprint: true }) },
+    rationale: "Create the governed Agent Swarm Teams table — reusable swarm blueprints (config, not runtime).",
+  };
+}
+
+export function findAgentTeamsObject(workspaceConfig) {
+  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  return objects.find((o) => o?.id === AGENT_SWARM_TEAMS_OBJECT_ID) || null;
+}
+
+export function findAgentTeams(workspaceConfig) {
+  const object = findAgentTeamsObject(workspaceConfig);
+  const rows = Array.isArray(object?.rows) ? object.rows : [];
+  const seen = new Set();
+  return rows
+    .filter((row) => row && clean(row.Name))
+    .map((row, index) => {
+      const name = clean(row.Name);
+      // Stable atomic identity: explicit id, else a slug of Name, else index —
+      // de-duplicated so two same-named blueprints never collide as React keys
+      // (the same fix applied to fleet reports).
+      let teamId = clean(row.id) || slugify(name) || `team-${index + 1}`;
+      while (seen.has(teamId)) teamId = `${teamId}-${index + 1}`;
+      seen.add(teamId);
+      return {
+        teamId,
+        name,
+        status: clean(row.status) || "blueprint",
+        teamPurpose: clean(row.teamPurpose),
+        orchestratorRole: clean(row.orchestratorRole),
+        orchestratorPrompt: clean(row.orchestratorPrompt),
+        subAgentRoles: clean(row.subAgentRoles),
+        skills: clean(row.skills),
+        processes: clean(row.processes),
+        workflowResponsibilities: clean(row.workflowResponsibilities),
+        outcomeCriteria: clean(row.outcomeCriteria),
+        defaultRunLocality: clean(row.defaultRunLocality),
+        defaultAdapter: clean(row.defaultAdapter),
+        linkedSwarmWorkflowName: clean(row.linkedSwarmWorkflowName),
+        governanceNotes: clean(row.governanceNotes),
+      };
+    });
+}
+
+/**
+ * Project the Agent Teams configuration layer for the cockpit. Pure.
+ *   { present, count, teams[], canCreate }
+ */
+export function deriveAgentTeamsState({ workspaceConfig } = {}) {
+  const object = findAgentTeamsObject(workspaceConfig);
+  const teams = findAgentTeams(workspaceConfig);
+  return {
+    objectId: AGENT_SWARM_TEAMS_OBJECT_ID,
+    present: Boolean(object),
+    count: teams.length,
+    teams,
+    // The table is created through the governed create lane when absent.
+    canCreate: !object,
+  };
+}
+
+function joinAgents(subAgentRoles) {
+  return clean(subAgentRoles)
+    .split(/[;,\n]/)
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Build the /swarm composer seed text from an Agent Team blueprint. This is
+ * PROPOSE-ONLY seed copy: it prefills the helper composer so the user proposes
+ * a governed swarm "from this blueprint". The model + server still produce the
+ * proposal and build the agent-swarm-v1 graph; nothing here executes.
+ */
+export function buildSwarmIntentFromTeam(team) {
+  if (!team) return "Propose a governed agent swarm:";
+  const agents = joinAgents(team.subAgentRoles);
+  const target = [
+    team.defaultAdapter ? `adapter ${team.defaultAdapter}` : "",
+    team.defaultRunLocality ? `${team.defaultRunLocality} run target` : "",
+  ].filter(Boolean).join(", ");
+  // Carry the full atomic configuration forward so the blueprint is a true
+  // configuration inversion of the swarm — still propose-only seed copy; the
+  // server builds the agent-swarm-v1 graph and nothing executes here.
+  const parts = [
+    `Propose a governed agent swarm from the Agent Team blueprint "${team.name}".`,
+    team.teamPurpose ? `Objective: ${team.teamPurpose}` : "",
+    team.orchestratorRole || team.orchestratorPrompt
+      ? `Orchestrator${team.orchestratorRole ? ` (${team.orchestratorRole})` : ""}: ${team.orchestratorPrompt || "plan the work for the team"}.`
+      : "",
+    agents.length ? `Sub-agents: ${agents.join(", ")}.` : "",
+    team.skills ? `Skills: ${team.skills}.` : "",
+    team.processes ? `Process: ${team.processes}.` : "",
+    team.workflowResponsibilities ? `Workflow responsibilities: ${team.workflowResponsibilities}.` : "",
+    team.outcomeCriteria ? `Outcome criteria: ${team.outcomeCriteria}.` : "",
+    target ? `Preferred execution target: ${target}.` : "",
+    team.governanceNotes ? `Governance notes: ${team.governanceNotes}.` : "",
+  ];
+  return parts.filter(Boolean).join(" ");
+}
+
+export function summarizeTeam(team) {
+  const agents = joinAgents(team?.subAgentRoles).length;
+  return [
+    team?.orchestratorRole ? `orchestrator: ${team.orchestratorRole}` : null,
+    agents ? `${agents} sub-agent${agents === 1 ? "" : "s"}` : null,
+  ].filter(Boolean).join(" · ");
+}
+
+export default deriveAgentTeamsState;