@growthub/cli 0.14.6 → 0.14.8

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

@@ -413,6 +413,11 @@ function buildRunResponse({
   if (result && typeof result === "object" && Array.isArray(result.logTree)) {
     base.logTree = result.logTree;
   }
+  // Per-node orchestration execution trace (general pipeline, not swarm) so the
+  // Workflow Canvas can settle per-node status from the persisted record.
+  if (result && typeof result === "object" && Array.isArray(result.nodeTrace)) {
+    base.nodeTrace = result.nodeTrace;
+  }
   base.exports = {
     available: ["download-json", "copy-output", "download-stdout", "download-stderr", "download-log-node"],
     external: []

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

@@ -20,7 +20,7 @@
 
 import { useEffect, useMemo, useState } from "react";
 import Link from "next/link";
-import { Activity, BarChart3, Check, Copy, Eye, GitBranch, MoreVertical, Search } from "lucide-react";
+import { Activity, BarChart3, Check, Copy, Eye, GitBranch, MoreVertical, Search, Share2 } from "lucide-react";
 import { deriveWorkspaceState, deriveSwarmConditionPacket, deriveWorkspaceContributions, deriveLensWalkthroughState, LENS_WALKTHROUGH_DISMISS_FLAG } from "@/lib/workspace-activation";
 import { WorkspaceContributionGraph } from "./WorkspaceContributionGraph.jsx";
 import { WorkspaceLensWalkthrough } from "./WorkspaceLensWalkthrough.jsx";
@@ -244,9 +244,10 @@ export function WorkspaceLensPanel({ workspaceConfig, workspaceSourceRecords, me
           <h1 className="workspace-lens-title">Workspace Lens</h1>
           <p className="workspace-lens-subtitle">Live derived state for this workspace.</p>
         </div>
-        <p className="workspace-lens-score" aria-label="Workspace lens summary">
-          {counts.total} lenses · {counts.ready} ready · {counts.blocked} blocked · {counts.assignable} agent-assignable
-        </p>
+        <Link className="workspace-lens-map-link" href="/workspace-map" aria-label="Open Workspace Map">
+          <Share2 size={15} aria-hidden="true" />
+          <span>Workspace Map</span>
+        </Link>
       </header>
 
       {showWalk ? (

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/DataModelShell.jsx

@@ -2390,6 +2390,7 @@ function DataModelTableSurface({
   const [selectMenuOpen, setSelectMenuOpen] = useState(false);
   const [pageSize, setPageSize] = useState(15);
   const [pageIndex, setPageIndex] = useState(0);
+  const [search, setSearch] = useState("");
   const fieldInputRef = useRef(null);
   const selectedOriginalIndex = selectedRecordIndex ?? localSelectedOriginalIndex;
 
@@ -2407,6 +2408,7 @@ function DataModelTableSurface({
     setLastSelectedRowIndex(null);
     setSelectMenuOpen(false);
     setPageIndex(0);
+    setSearch("");
   }, [table.id]);
 
   useEffect(() => {
@@ -2428,7 +2430,14 @@ function DataModelTableSurface({
   const visibleColumns = useMemo(() => orderedColumns.filter((column) => !settings.hidden.includes(column)), [orderedColumns, settings.hidden]);
   const rowEntries = useMemo(() => {
     const indexed = (table.rows || []).map((row, originalIndex) => ({ row, originalIndex }));
-    const filtered = indexed.filter((entry) => rowMatchesFilter(entry.row, settings.filter));
+    const needle = search.trim().toLowerCase();
+    const filtered = indexed.filter((entry) => {
+      if (!rowMatchesFilter(entry.row, settings.filter)) return false;
+      if (!needle) return true;
+      // Quick search across the visible columns only — additive to the
+      // column-level filter clauses, never replaces them.
+      return visibleColumns.some((column) => String(entry.row?.[column] ?? "").toLowerCase().includes(needle));
+    });
     if (!settings.sort?.length) return filtered;
     const clauses = settings.sort;
     return [...filtered].sort((left, right) => {
@@ -2439,7 +2448,7 @@ function DataModelTableSurface({
       }
       return 0;
     });
-  }, [table.rows, settings]);
+  }, [table.rows, settings, search, visibleColumns]);
   const selectedRowCount = selectedRows.size;
   const pageCount = Math.max(1, Math.ceil(rowEntries.length / pageSize));
   const safePageIndex = Math.min(pageIndex, pageCount - 1);
@@ -2491,7 +2500,7 @@ function DataModelTableSurface({
     setSelectedRow(null);
     setLastSelectedRowIndex(null);
     setSelectMenuOpen(false);
-  }, [settings.filter, settings.sort, pageSize]);
+  }, [settings.filter, settings.sort, pageSize, search]);
 
   function commitField() {
     const name = fieldName.trim();
@@ -2690,9 +2699,25 @@ function DataModelTableSurface({
           ))}
         </div>
         <div className="dm-records-actions">
+          <label className="dm-toolbar-search">
+            <Search size={13} aria-hidden="true" />
+            <input
+              value={search}
+              placeholder="Search records"
+              onChange={(event) => setSearch(event.target.value)}
+              aria-label={`Search ${table.label || "records"}`}
+            />
+          </label>
+          <span className="dm-toolbar-count">
+            {(search.trim() || settings.filter?.clauses?.length)
+              ? `${rowEntries.length} of ${pluralize(table.rows?.length || 0, "record")}`
+              : pluralize(table.rows?.length || 0, "record")}
+          </span>
+          <span className="dm-toolbar-divider" aria-hidden="true" />
           <span className="dm-filter-anchor">
-            <button type="button" className="dm-btn-ghost" onClick={() => setFilterTarget((current) => current === "toolbar" ? "" : "toolbar")}>
+            <button type="button" className={`dm-btn-ghost${settings.filter?.clauses?.length ? " is-active" : ""}`} onClick={() => setFilterTarget((current) => current === "toolbar" ? "" : "toolbar")}>
               <Filter size={13} />Filter
+              {settings.filter?.clauses?.length > 0 && <span className="dm-filter-chip-count">{settings.filter.clauses.length}</span>}
             </button>
             {filterTarget === "toolbar" && (
               <div className="dm-filter-popover dm-filter-popover-toolbar">
@@ -2843,6 +2868,35 @@ function DataModelTableSurface({
             </tr>
           </thead>
           <tbody>
+            {rowEntries.length === 0 && (
+              <tr className="dm-db-empty-row">
+                <td colSpan={visibleColumns.length + 1 + (table.mutable ? 1 : 0)}>
+                  <div className="dm-db-empty-state">
+                    {(search.trim() || settings.filter?.clauses?.length) ? (
+                      <>
+                        <strong>No records match</strong>
+                        <span>Try a different search or clear your filters.</span>
+                        <div className="dm-db-empty-actions">
+                          {search.trim() && <button type="button" className="dm-btn-outline" onClick={() => setSearch("")}>Clear search</button>}
+                          {settings.filter?.clauses?.length > 0 && <button type="button" className="dm-btn-outline" onClick={resetView}>Reset view</button>}
+                        </div>
+                      </>
+                    ) : (
+                      <>
+                        <strong>No records yet</strong>
+                        <span>{table.mutable ? "Add your first row or import a CSV to start using this object." : "Records resolve at runtime for this live-backed object."}</span>
+                        {table.mutable && (
+                          <div className="dm-db-empty-actions">
+                            <button type="button" className="dm-btn-primary-sm" disabled={saving} onClick={() => onSave((config) => addTableRow(config, table))}><Plus size={13} />Add record</button>
+                            <button type="button" className="dm-btn-outline" onClick={() => setCsvOpen(true)}><Upload size={13} />Import CSV</button>
+                          </div>
+                        )}
+                      </>
+                    )}
+                  </div>
+                </td>
+              </tr>
+            )}
             {pageEntries.map(({ row, originalIndex }, rowIndex) => {
               const visibleIndex = pageStart + rowIndex;
               const displayIndex = visibleIndex + 1;

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/OrchestrationGraphCanvas.jsx

@@ -103,6 +103,21 @@ function nodeRecordName(node) {
   return "";
 }
 
+// Per-node run-status pill (Attio-style), docked outside the node top-right.
+// Driven only by the real general-orchestration run signal passed in
+// `nodeStatuses` — the streamed orchestration.node.* deltas and the persisted
+// nodeTrace (see lib/orchestration-node-status.js). Never fabricated here.
+const NODE_STATUS_CHIP = {
+  completed: { cls: "is-ok", label: "Completed" },
+  ok: { cls: "is-ok", label: "Completed" },
+  running: { cls: "is-running", label: "Running" },
+  executing: { cls: "is-running", label: "Running" },
+  failed: { cls: "is-bad", label: "Failed" },
+  skipped: { cls: "is-waiting", label: "Skipped" },
+  pending: { cls: "is-waiting", label: "Waiting" },
+  queued: { cls: "is-waiting", label: "Waiting" },
+};
+
 export function OrchestrationGraphCanvas({
   graph,
   selectedNodeId,
@@ -112,6 +127,8 @@ export function OrchestrationGraphCanvas({
   onRunTest,
   runStatus,
   runMessage,
+  nodeStatuses,
+  onNodeStatusClick,
   statusLabel = "Draft",
 }) {
   const parsed = useMemo(() => parseOrchestrationGraph(graph) || graph, [graph]);
@@ -222,6 +239,9 @@ export function OrchestrationGraphCanvas({
           const isSelected = activeId === id;
           const prevId = index > 0 ? String(nodes[index - 1].id || "") : "";
           const Icon = NODE_ICONS[node.type] || ArrowDownToLine;
+          const nodeStatusChip = nodeStatuses
+            ? NODE_STATUS_CHIP[String(nodeStatuses[id] || "").toLowerCase()] || null
+            : null;
 
           return (
             <div key={id || index} className="dm-orchestration-canvas__step">
@@ -285,6 +305,17 @@ export function OrchestrationGraphCanvas({
                   onSelectNode?.(node);
                 }}
               >
+                {nodeStatusChip && (
+                  <button
+                    type="button"
+                    className={`dm-status-chip ${nodeStatusChip.cls} dm-orchestration-node__status`}
+                    title={`${nodeStatusChip.label} — open run trace`}
+                    onClick={(event) => { event.stopPropagation(); onNodeStatusClick?.(node); }}
+                  >
+                    <span className="dm-status-dot" aria-hidden="true" />
+                    {nodeStatusChip.label}
+                  </button>
+                )}
                 <span className="dm-orchestration-node__icon" aria-hidden="true">
                   <Icon size={14} />
                 </span>

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/StatusPill.jsx

@@ -1,13 +1,29 @@
 "use client";
 
+// Maps a free-form status string to one calm, consistent chip state.
+// Backwards-compatible: same { value } prop, same default ("untested").
+const OK = ["connected", "approved", "ok", "success", "succeeded", "complete", "completed", "passed", "live", "ready"];
+const BAD = ["failed", "error", "errored", "disconnected", "rejected"];
+const WARN = ["warning", "warn", "pending", "untrusted", "stale", "degraded"];
+const RUNNING = ["running", "in_progress", "in-progress", "active", "executing", "started"];
+const WAITING = ["waiting", "queued", "idle", "scheduled"];
+
+function classifyStatus(status) {
+  if (OK.includes(status)) return "is-ok";
+  if (BAD.includes(status)) return "is-bad";
+  if (RUNNING.includes(status)) return "is-running";
+  if (WARN.includes(status)) return "is-warn";
+  if (WAITING.includes(status)) return "is-waiting";
+  return "";
+}
+
 export function StatusPill({ value }) {
-  const status = String(value || "untested").toLowerCase();
-  const ok = ["connected", "approved", "ok", "success"].includes(status);
-  const bad = ["failed", "error", "disconnected"].includes(status);
+  const raw = value || "untested";
+  const state = classifyStatus(String(raw).toLowerCase());
   return (
-    <span className={`dm-db-status ${ok ? "ok" : bad ? "bad" : ""}`}>
-      <span />
-      {value || "untested"}
+    <span className={`dm-status-chip ${state}`.trim()}>
+      <span className="dm-status-dot" />
+      {raw}
     </span>
   );
 }

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/ToggleField.jsx

@@ -2,16 +2,17 @@
 
 export function ToggleField({ checked, disabled, label, onChange, description }) {
   return (
-    <label className="dm-check-row">
+    <label className={`dm-switch-row${disabled ? " is-disabled" : ""}`}>
       <input
         type="checkbox"
         checked={Boolean(checked)}
         disabled={disabled}
         onChange={(event) => onChange(event.target.checked)}
       />
-      <span>
-        {label}
-        {description && <span className="dm-cell-empty" style={{ display: "block", marginTop: 4 }}>{description}</span>}
+      <span className="dm-switch-track" aria-hidden="true" />
+      <span className="dm-switch-label">
+        <span>{label}</span>
+        {description && <span className="dm-switch-desc">{description}</span>}
       </span>
     </label>
   );

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/data-model/components/WorkspaceDataModelCanvas.jsx

@@ -0,0 +1,457 @@
+"use client";
+
+/**
+ * Workspace Map — read-only schema/relationship canvas.
+ *
+ * Renders the workspace data model as a node canvas using the SAME visual
+ * grammar as the workflow OrchestrationGraphCanvas (dotted grid, card nodes,
+ * connector edges, zoom controls), but the CONTENT is the metadata graph, not
+ * an executable workflow.
+ *
+ * Hard rules (mirrors the kit's governance invariants):
+ *   - Graph data comes ONLY from buildWorkspaceMetadataStore →
+ *     buildWorkspaceMetadataGraph. No ad-hoc config parsing here.
+ *   - No mutations, no PATCH, no localStorage. This surface only reads
+ *     /api/workspace and navigates to existing surfaces on click.
+ *   - Secrets never reach the graph (the store strips them); we render only
+ *     labels, counts, and types.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { ArrowLeft, Maximize2, Search, X, ZoomIn, ZoomOut } from "lucide-react";
+
+import { buildWorkspaceMetadataStore } from "@/lib/workspace-metadata-store";
+import { buildWorkspaceMetadataGraph } from "@/lib/workspace-metadata-graph";
+import { LucideIcon, OBJECT_TYPE_PRESETS, objectTypeBadge, pluralize } from "./dm-shared.jsx";
+
+// Which node types appear on the map, in lane (left→right) order, with the
+// icon + legend swatch for each. Workflow execution detail (nodes, inputs,
+// runs) stays in the Workflow Canvas — the map is the structural overview.
+const LANES = [
+  { key: "integration", types: ["integration"], label: "Integrations", icon: "Globe", color: "#0ea5e9" },
+  { key: "source", types: ["sourceRecord"], label: "Sources", icon: "Database", color: "#14b8a6" },
+  { key: "object", types: ["dataModelObject"], label: "Objects", icon: "Box", color: "#4f6bed" },
+  { key: "flow", types: ["workflow", "sandbox"], label: "Workflows", icon: "Zap", color: "#8b5cf6" },
+  { key: "dashboard", types: ["dashboard"], label: "Dashboards", icon: "LayoutDashboard", color: "#f97316" },
+];
+
+const RENDERED_TYPES = new Set(LANES.flatMap((lane) => lane.types));
+const NODE_WIDTH = 220;
+const COL_GAP = 60;
+const ROW_GAP = 24;
+const PAD = 28;
+
+function nodeHeight(node) {
+  // Object cards carry a field strip + stat → taller. Everything else is compact.
+  return node.type === "dataModelObject" ? 122 : 80;
+}
+
+function nodeIconName(node) {
+  if (node.type === "dataModelObject") {
+    return node.summary?.objectType
+      ? OBJECT_TYPE_PRESETS[node.summary.objectType]?.icon || "Box"
+      : "Box";
+  }
+  const lane = LANES.find((entry) => entry.types.includes(node.type));
+  return lane?.icon || "Box";
+}
+
+export function WorkspaceDataModelCanvas() {
+  const router = useRouter();
+  const [workspaceConfig, setWorkspaceConfig] = useState(null);
+  const [sourceRecords, setSourceRecords] = useState({});
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState("");
+  const [scale, setScale] = useState(1);
+  const [selectedId, setSelectedId] = useState("");
+  const [query, setQuery] = useState("");
+  const canvasRef = useRef(null);
+  const dragRef = useRef(null);
+  const [isPanning, setIsPanning] = useState(false);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    setError("");
+    try {
+      const res = await fetch("/api/workspace", { cache: "no-store" });
+      const payload = await res.json();
+      if (!res.ok) throw new Error(payload.error || "Failed to load workspace");
+      setWorkspaceConfig(payload.workspaceConfig || null);
+      setSourceRecords(
+        payload.workspaceSourceRecords && typeof payload.workspaceSourceRecords === "object"
+          ? payload.workspaceSourceRecords
+          : {}
+      );
+    } catch (err) {
+      setError(err.message || "Failed to load workspace");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  // Derived graph — never throws on malformed config (the store/graph guard).
+  const graph = useMemo(() => {
+    if (!workspaceConfig) return { nodes: [], edges: [] };
+    try {
+      const store = buildWorkspaceMetadataStore({
+        workspaceConfig,
+        workspaceSourceRecords: sourceRecords,
+      });
+      return buildWorkspaceMetadataGraph(store);
+    } catch {
+      return { nodes: [], edges: [] };
+    }
+  }, [workspaceConfig, sourceRecords]);
+
+  // Group field labels by the object id they belong to, for the object cards.
+  const fieldsByObjectId = useMemo(() => {
+    const map = new Map();
+    for (const node of graph.nodes) {
+      if (node.type !== "field") continue;
+      const objectId = node.summary?.objectId;
+      if (!objectId) continue;
+      if (!map.has(objectId)) map.set(objectId, []);
+      map.get(objectId).push(node.label);
+    }
+    return map;
+  }, [graph.nodes]);
+
+  // Deterministic lane layout — no randomness, stable across renders.
+  const { placed, positions, width, height } = useMemo(() => {
+    const positionMap = new Map();
+    const placedNodes = [];
+    let maxBottom = 0;
+    LANES.forEach((lane, laneIndex) => {
+      const laneNodes = graph.nodes.filter((node) => lane.types.includes(node.type));
+      const x = PAD + laneIndex * (NODE_WIDTH + COL_GAP);
+      let y = PAD;
+      for (const node of laneNodes) {
+        const h = nodeHeight(node);
+        positionMap.set(node.id, { x, y, w: NODE_WIDTH, h });
+        placedNodes.push(node);
+        y += h + ROW_GAP;
+      }
+      maxBottom = Math.max(maxBottom, y);
+    });
+    return {
+      placed: placedNodes,
+      positions: positionMap,
+      width: PAD + LANES.length * (NODE_WIDTH + COL_GAP),
+      height: Math.max(maxBottom, 460),
+    };
+  }, [graph.nodes]);
+
+  // Only edges whose BOTH endpoints are rendered on the map. Deduped by id.
+  const edges = useMemo(() => {
+    const seen = new Set();
+    const out = [];
+    for (const edge of graph.edges) {
+      if (!positions.has(edge.from) || !positions.has(edge.to)) continue;
+      if (seen.has(edge.id)) continue;
+      seen.add(edge.id);
+      out.push(edge);
+    }
+    return out;
+  }, [graph.edges, positions]);
+
+  const needle = query.trim().toLowerCase();
+  const matches = useCallback(
+    (node) => {
+      if (!needle) return true;
+      const s = node.summary || {};
+      // Match the fields a customer actually searches by — object type, source
+      // id, integration/status, workflow lifecycle, adapter/auth, fetched date —
+      // not just label/type.
+      const haystack = [
+        node.label, node.type,
+        s.objectType, s.objectId, s.status, s.lane, s.lifecycleStatus,
+        s.adapter, s.authStatus, s.authProvider, s.integrationId,
+        s.runLocality, s.fetchedAt, s.sourceAuthority,
+      ].filter(Boolean).join(" ").toLowerCase();
+      return haystack.includes(needle);
+    },
+    [needle]
+  );
+
+  // Human-readable label for the open action, by node type.
+  function openLabel(node) {
+    if (node.type === "workflow" || node.type === "sandbox") return "Open in Workflow Canvas";
+    return "Open in Data Model";
+  }
+
+  // Read-only metadata rows for the detail panel — derived from the graph
+  // summary only (no secrets, no config parsing).
+  function detailRows(node) {
+    const s = node.summary || {};
+    const rows = [];
+    const push = (k, v) => { if (v !== undefined && v !== null && v !== "") rows.push({ k, v: String(v) }); };
+    if (node.type === "dataModelObject") {
+      push("Type", s.objectType);
+      push("Records", Number.isFinite(s.rowCount) ? s.rowCount : undefined);
+      push("Backing", s.isLiveBacked ? "live" : s.readOnly ? "read-only" : "manual");
+      push("Source authority", s.sourceAuthority);
+    } else if (node.type === "sourceRecord") {
+      push("Records", Number.isFinite(s.recordCount) ? s.recordCount : 0);
+      push("Integration", s.integrationId);
+      push("Fetched", s.fetchedAt ? String(s.fetchedAt).slice(0, 10) : undefined);
+    } else if (node.type === "workflow") {
+      push("Steps", Number.isFinite(s.nodeCount) ? s.nodeCount : 0);
+      push("Lifecycle", s.lifecycleStatus);
+      push("Requires input", s.requiresInput ? "yes" : undefined);
+    } else if (node.type === "sandbox") {
+      push("Adapter", s.adapter);
+      push("Auth", s.authStatus);
+      push("Locality", s.runLocality);
+      push("Lifecycle", s.lifecycleStatus);
+    } else if (node.type === "integration") {
+      push("Status", s.status);
+      push("Lane", s.lane);
+    } else if (node.type === "dashboard") {
+      push("Widgets", Number.isFinite(s.widgetCount) ? s.widgetCount : 0);
+    }
+    return rows;
+  }
+
+  const selectedNode = useMemo(
+    () => placed.find((node) => node.id === selectedId) || null,
+    [placed, selectedId]
+  );
+
+  function handleOpen(node) {
+    const summary = node.summary || {};
+    if (node.type === "dataModelObject") {
+      router.push(`/data-model?object=${encodeURIComponent(summary.objectId || "")}`);
+    } else if (node.type === "workflow" || node.type === "sandbox") {
+      const params = new URLSearchParams();
+      if (summary.objectId) params.set("object", summary.objectId);
+      if (summary.rowId) params.set("row", summary.rowId);
+      // Explicit field for consistency with the CEO/Agent Team handoff pattern;
+      // WorkflowSurface still falls back to orchestrationGraph if absent.
+      params.set("field", "orchestrationConfig");
+      router.push(`/workflows${params.toString() ? `?${params.toString()}` : ""}`);
+    } else {
+      router.push("/data-model");
+    }
+  }
+
+  function zoom(delta) {
+    setScale((current) => Math.min(1.4, Math.max(0.6, Math.round((current + delta) * 10) / 10)));
+  }
+
+  const handleCanvasPointerDown = useCallback((event) => {
+    if (event.button !== 0) return;
+    const target = event.target;
+    if (target?.closest?.("button, a, input, label, .wm-detail, .wm-zoom")) return;
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    dragRef.current = {
+      pointerId: event.pointerId,
+      startX: event.clientX,
+      startY: event.clientY,
+      scrollLeft: canvas.scrollLeft,
+      scrollTop: canvas.scrollTop,
+    };
+    setIsPanning(true);
+    event.currentTarget.setPointerCapture?.(event.pointerId);
+  }, []);
+
+  const handleCanvasPointerMove = useCallback((event) => {
+    const drag = dragRef.current;
+    const canvas = canvasRef.current;
+    if (!drag || !canvas || drag.pointerId !== event.pointerId) return;
+    event.preventDefault();
+    canvas.scrollLeft = drag.scrollLeft - (event.clientX - drag.startX);
+    canvas.scrollTop = drag.scrollTop - (event.clientY - drag.startY);
+  }, []);
+
+  const endCanvasPan = useCallback((event) => {
+    if (dragRef.current?.pointerId !== event.pointerId) return;
+    dragRef.current = null;
+    setIsPanning(false);
+  }, []);
+
+  const hasNodes = placed.length > 0;
+
+  return (
+    <div className="wm-shell">
+      <div className="wm-toolbar">
+        <Link className="wm-back-link" href="/workspace-lens" aria-label="Back to Workspace Lens">
+          <ArrowLeft size={16} aria-hidden="true" />
+        </Link>
+        <div>
+          <h1>Workspace Map</h1>
+          <span className="wm-sub">
+            {hasNodes ? `${pluralize(placed.length, "node")} · ${pluralize(edges.length, "link")}` : "Read-only view of your workspace data model"}
+          </span>
+        </div>
+        <label className="dm-toolbar-search" style={{ marginLeft: 16 }}>
+          <Search size={13} aria-hidden="true" />
+          <input
+            value={query}
+            placeholder="Search objects, sources, workflows"
+            onChange={(event) => setQuery(event.target.value)}
+            aria-label="Search the workspace map"
+          />
+        </label>
+        <div className="wm-legend">
+          {LANES.map((lane) => (
+            <span key={lane.key} className="wm-legend-item">
+              <span className="wm-legend-swatch" style={{ background: lane.color }} />
+              {lane.label}
+            </span>
+          ))}
+        </div>
+      </div>
+
+      <div
+        ref={canvasRef}
+        className={`wm-canvas${isPanning ? " is-panning" : ""}`}
+        onPointerDown={handleCanvasPointerDown}
+        onPointerMove={handleCanvasPointerMove}
+        onPointerUp={endCanvasPan}
+        onPointerCancel={endCanvasPan}
+        onPointerLeave={endCanvasPan}
+      >
+        {loading && <div className="wm-empty"><span>Loading workspace map…</span></div>}
+        {!loading && error && <div className="wm-empty"><strong>Could not load the map</strong><span>{error}</span></div>}
+        {!loading && !error && !hasNodes && (
+          <div className="wm-empty">
+            <strong>Nothing to map yet</strong>
+            <span>Add objects, link a data source, or publish a workflow and they will appear here.</span>
+          </div>
+        )}
+        {!loading && !error && hasNodes && (
+          <>
+            {/* Sizer reserves the SCALED footprint so .wm-canvas (overflow:auto)
+                scrolls fully when zoomed in on dense workspaces. The inner
+                layer holds the unscaled coordinate system and is transformed. */}
+            <div className="wm-canvas-inner" style={{ width: width * scale, height: height * scale }}>
+              <div className="wm-canvas-scale" style={{ width, height, transform: `scale(${scale})` }}>
+              <svg className="wm-edge" width={width} height={height} style={{ left: 0, top: 0 }}>
+                <defs>
+                  <marker id="wm-arrow" markerWidth="7" markerHeight="7" refX="6" refY="3" orient="auto" markerUnits="userSpaceOnUse">
+                    <path className="wm-arrow-head" d="M0,0 L6,3 L0,6 Z" />
+                  </marker>
+                </defs>
+                {edges.map((edge) => {
+                  const a = positions.get(edge.from);
+                  const b = positions.get(edge.to);
+                  if (!a || !b) return null;
+                  const overlapsX = Math.max(a.x, b.x) < Math.min(a.x + a.w, b.x + b.w);
+                  const [top, bottom] = a.y <= b.y ? [a, b] : [b, a];
+                  const [left, right] = a.x <= b.x ? [a, b] : [b, a];
+                  const cls = ["backedBySourceRecord", "boundToIntegration", "belongsToIntegration"].includes(edge.relation)
+                    ? "is-source"
+                    : "";
+                  const d = overlapsX
+                    ? `M ${top.x + top.w / 2} ${top.y + top.h} L ${bottom.x + bottom.w / 2} ${bottom.y}`
+                    : [
+                        `M ${left.x + left.w} ${left.y + left.h / 2}`,
+                        `H ${(left.x + left.w + right.x) / 2}`,
+                        `V ${right.y + right.h / 2}`,
+                        `H ${right.x}`,
+                      ].join(" ");
+                  return <path key={edge.id} className={cls} d={d} markerEnd="url(#wm-arrow)" />;
+                })}
+              </svg>
+              {placed.map((node) => {
+                const pos = positions.get(node.id);
+                const dim = needle && !matches(node);
+                const isObject = node.type === "dataModelObject";
+                const badge = isObject ? objectTypeBadge(node.summary?.objectType) : null;
+                const fields = isObject ? (fieldsByObjectId.get(node.summary?.objectId) || []).slice(0, 5) : [];
+                const rowCount = node.summary?.rowCount;
+                const recordCount = node.summary?.recordCount;
+                return (
+                  <button
+                    type="button"
+                    key={node.id}
+                    className={`wm-node${node.id === selectedId ? " is-selected" : ""}`}
+                    style={{ left: pos.x, top: pos.y, width: pos.w, opacity: dim ? 0.32 : 1 }}
+                    onClick={() => setSelectedId(node.id)}
+                    aria-pressed={node.id === selectedId}
+                    title={`Inspect ${node.label}`}
+                  >
+                    <span className="wm-node-head">
+                      <span className="wm-node-icon"><LucideIcon name={nodeIconName(node)} size={14} /></span>
+                      <span className="wm-node-title">{node.label || node.type}</span>
+                      {badge && <span className={`dm-badge ${badge.cls}`}>{badge.label}</span>}
+                    </span>
+                    <span className="wm-node-body">
+                      {isObject && (
+                        <span className="wm-node-stat">
+                          {Number.isFinite(rowCount) ? pluralize(rowCount, "record") : "—"}
+                          {node.summary?.isLiveBacked ? " · live" : node.summary?.readOnly ? " · read-only" : " · manual"}
+                        </span>
+                      )}
+                      {node.type === "sourceRecord" && (
+                        <span className="wm-node-stat">
+                          {Number.isFinite(recordCount) ? pluralize(recordCount, "record") : "no records"}
+                          {node.summary?.fetchedAt ? ` · fetched ${String(node.summary.fetchedAt).slice(0, 10)}` : ""}
+                        </span>
+                      )}
+                      {node.type === "workflow" && (
+                        <span className="wm-node-stat">
+                          {pluralize(node.summary?.nodeCount || 0, "step")}
+                          {node.summary?.lifecycleStatus ? ` · ${node.summary.lifecycleStatus}` : ""}
+                        </span>
+                      )}
+                      {node.type === "sandbox" && (
+                        <span className="wm-node-stat">
+                          {node.summary?.adapter || "sandbox"}
+                          {node.summary?.authStatus ? ` · ${node.summary.authStatus}` : ""}
+                        </span>
+                      )}
+                      {node.type === "integration" && (
+                        <span className="wm-node-stat">{node.summary?.status || node.summary?.lane || "integration"}</span>
+                      )}
+                      {node.type === "dashboard" && (
+                        <span className="wm-node-stat">{pluralize(node.summary?.widgetCount || 0, "widget")}</span>
+                      )}
+                      {fields.length > 0 && (
+                        <span className="wm-node-fields">
+                          {fields.map((field, index) => (
+                            <span key={`${node.id}-f-${index}`} className="wm-node-field">{field}</span>
+                          ))}
+                        </span>
+                      )}
+                    </span>
+                  </button>
+                );
+              })}
+              </div>
+            </div>
+            <div className="wm-zoom" role="group" aria-label="Zoom controls">
+              <button type="button" onClick={() => zoom(-0.1)} aria-label="Zoom out"><ZoomOut size={15} /></button>
+              <button type="button" onClick={() => setScale(1)} aria-label="Reset zoom"><Maximize2 size={14} /></button>
+              <button type="button" onClick={() => zoom(0.1)} aria-label="Zoom in"><ZoomIn size={15} /></button>
+            </div>
+            {selectedNode && (
+              <aside className="wm-detail" aria-label={`${selectedNode.label} detail`}>
+                <div className="wm-detail-head">
+                  <span className="wm-node-icon"><LucideIcon name={nodeIconName(selectedNode)} size={14} /></span>
+                  <span className="wm-detail-title">{selectedNode.label || selectedNode.type}</span>
+                  <button type="button" className="wm-detail-close" aria-label="Close detail" onClick={() => setSelectedId("")}><X size={14} /></button>
+                </div>
+                <dl className="wm-detail-meta">
+                  {detailRows(selectedNode).map((row) => (
+                    <div key={row.k} className="wm-detail-row"><dt>{row.k}</dt><dd>{row.v}</dd></div>
+                  ))}
+                </dl>
+                <button type="button" className="dm-btn-primary-sm wm-detail-cta" onClick={() => handleOpen(selectedNode)}>
+                  {openLabel(selectedNode)}
+                </button>
+              </aside>
+            )}
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export default WorkspaceDataModelCanvas;

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/globals.css

@@ -8977,10 +8977,14 @@ body.workspace-rail-collapsed .workspace-builder.workspace-lens-page,
 .workspace-lens-surface { width: 100%; padding: 0; background: #f7f7f8; overflow-y: auto; overflow-x: hidden; }
 .workspace-lens-shell { width: 100%; max-width: none; margin: 0; padding: 24px 28px 32px; }
 .workspace-lens-locked { border: 1px solid #e5e7eb; border-radius: 10px; background: #fff; padding: 28px; max-width: 560px; margin: 48px auto; display: flex; flex-direction: column; gap: 8px; }
-.workspace-lens-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 16px; flex-wrap: wrap; margin-bottom: 16px; }
+.workspace-lens-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 16px; margin-bottom: 16px; }
+.workspace-lens-head > div { min-width: 0; }
 .workspace-lens-title { font-size: 18px; font-weight: 600; color: #111827; margin: 0; }
 .workspace-lens-subtitle { font-size: 13px; color: #6b7280; margin: 4px 0 0; }
-.workspace-lens-score { font-size: 12px; color: #4b5563; font-variant-numeric: tabular-nums; margin: 2px 0 0; }
+.workspace-lens-map-link { flex: 0 0 auto; display: inline-flex; align-items: center; justify-content: center; gap: 8px; min-height: 34px; border: 1px solid #d8dee8; border-radius: 8px; background: #ffffff; color: #111827; padding: 0 12px; text-decoration: none; font-size: 13px; font-weight: 600; box-shadow: 0 1px 2px rgba(15, 23, 42, 0.05); }
+.workspace-lens-map-link:hover { background: #f9fafb; border-color: #cfd7e3; color: #111827; }
+.workspace-lens-map-link:focus-visible { outline: 2px solid #bfdbfe; outline-offset: 2px; }
+.workspace-lens-map-link svg { color: #4b5563; flex-shrink: 0; }
 .workspace-lens-controls.workspace-builder-filterbar { margin: 0 0 14px; border: 1px solid #e8edf3; border-radius: 8px; background: #fff; }
 .workspace-lens-filters.workspace-builder-filterbar__segments { max-width: 100%; overflow-x: auto; }
 .workspace-lens-filter { white-space: nowrap; }
@@ -9034,12 +9038,17 @@ body.workspace-rail-collapsed .workspace-builder.workspace-lens-page,
 .workspace-lens-action-menu button:hover,
 .workspace-lens-action-menu a:hover { background: #f3f4f6; }
 @media (max-width: 1100px) {
+  .workspace-lens-head { align-items: flex-start; }
   .workspace-lens-control-grid { grid-template-columns: 1fr; }
   .workspace-lens-branch-row { grid-template-columns: 1fr; align-items: flex-start; padding: 10px 12px; gap: 8px; }
   .workspace-lens-branch-actions { justify-content: flex-start; flex-wrap: wrap; }
   .workspace-lens-branch-summary,
   .workspace-lens-branch-next { margin-left: 22px; }
 }
+@media (max-width: 640px) {
+  .workspace-lens-head { flex-direction: column; }
+  .workspace-lens-map-link { align-self: stretch; }
+}
 .workspace-lens-stream { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 8px; }
 .workspace-lens-card { border: 1px solid #e8edf3; border-radius: 10px; background: #fff; padding: 12px 14px; }
 .workspace-lens-card.is-ready { opacity: 0.7; }
@@ -9261,3 +9270,180 @@ body.workspace-rail-collapsed .workspace-builder.workspace-lens-page,
 .dm-swarm-expand-head { justify-content: flex-start; gap: 8px; }
 .dm-swarm-expand-body { flex: 1; min-height: 0; overflow-y: auto; padding: 12px 14px; }
 .dm-swarm-expand-body .dm-helper-toolcall-json { max-height: none; }
+
+/* ════════════════════════════════════════════════════════════════════════
+   SaaS facelift layer — Attio-inspired polish (v0.14.8)
+   Additive only. Refines existing dm-* light-theme primitives via the
+   cascade (equal specificity, later wins) and introduces the shared
+   vocabulary consumed by the table, drawer, Workspace Map, and run-status
+   work. No new theme, no token renames — existing classes keep working.
+   ──────────────────────────────────────────────────────────────────────── */
+:root {
+  /* Calm, unified surface system for the light data-model surfaces. */
+  --dm-line: #e7eaee;          /* default hairline border */
+  --dm-line-soft: #f0f2f5;     /* inner cell / row separators */
+  --dm-surface: #ffffff;
+  --dm-surface-soft: #fafbfc;  /* headers, toolbars, footers */
+  --dm-hover: #f6f8fa;         /* calm row/control hover */
+  --dm-ink: #1f2733;           /* primary text */
+  --dm-muted: #6b7686;         /* secondary text */
+  --dm-faint: #9aa4b2;         /* tertiary / placeholder */
+  --dm-accent: #4f6bed;        /* single accent — active states only */
+  --dm-accent-soft: #eef1fe;   /* accent background wash */
+  --dm-accent-line: #c9d3fb;   /* accent border */
+  --dm-radius: 8px;
+  --dm-radius-sm: 6px;
+  --dm-radius-lg: 12px;
+  --dm-shadow-pop: 0 12px 32px rgba(20, 28, 46, 0.12), 0 2px 6px rgba(20, 28, 46, 0.06);
+  --dm-ok: #16a34a;
+  --dm-ok-soft: #f0fdf4;
+  --dm-ok-line: #bbf7d0;
+  --dm-bad: #dc2626;
+  --dm-bad-soft: #fef2f2;
+  --dm-bad-line: #fecaca;
+  --dm-warn: #d97706;
+  --dm-warn-soft: #fffbeb;
+  --dm-warn-line: #fde68a;
+  --dm-run: #4f6bed;
+  --dm-run-soft: #eef1fe;
+  --dm-run-line: #c9d3fb;
+}
+
+/* ── Toolbar + buttons: softer borders, unified radius/hover ───────────── */
+.dm-db-toolbar { border-bottom-color: var(--dm-line); }
+.dm-btn-ghost { border-radius: var(--dm-radius-sm); border-color: var(--dm-line); color: var(--dm-muted); }
+.dm-btn-ghost:hover { background: var(--dm-hover); border-color: #d3d9e0; color: var(--dm-ink); }
+.dm-btn-ghost.is-active { background: var(--dm-accent-soft); border-color: var(--dm-accent-line); color: var(--dm-accent); }
+.dm-btn-outline { border-radius: var(--dm-radius-sm); border-color: var(--dm-line); }
+.dm-btn-primary-sm { border-radius: var(--dm-radius-sm); }
+
+/* ── Compact search field for the table toolbar (P1) ──────────────────── */
+.dm-toolbar-search { display: inline-flex; align-items: center; gap: 6px; height: 28px; padding: 0 9px; border: 1px solid var(--dm-line); border-radius: var(--dm-radius-sm); background: var(--dm-surface); color: var(--dm-faint); transition: border-color .12s, box-shadow .12s; }
+.dm-toolbar-search:focus-within { border-color: var(--dm-accent-line); box-shadow: 0 0 0 3px var(--dm-accent-soft); }
+.dm-toolbar-search input { border: 0; outline: 0; background: transparent; font: inherit; font-size: 12px; color: var(--dm-ink); width: 150px; }
+.dm-toolbar-search input::placeholder { color: var(--dm-faint); }
+.dm-toolbar-count { display: inline-flex; align-items: center; height: 22px; padding: 0 8px; border-radius: 999px; background: var(--dm-surface-soft); border: 1px solid var(--dm-line); color: var(--dm-muted); font-size: 11px; font-weight: 650; font-variant-numeric: tabular-nums; }
+.dm-toolbar-divider { width: 1px; align-self: stretch; margin: 2px 2px; background: var(--dm-line); }
+
+/* ── Filter / sort pill chips: calmer, clearer active state ───────────── */
+.dm-filter-chip { border-radius: var(--dm-radius-sm); border-color: var(--dm-accent-line); background: var(--dm-accent-soft); color: var(--dm-accent); font-weight: 600; transition: background .12s, border-color .12s; }
+.dm-filter-chip:hover { background: #e4e9fd; }
+.dm-filter-chip-count { margin-left: 1px; min-width: 16px; height: 16px; padding: 0 4px; display: inline-flex; align-items: center; justify-content: center; border-radius: 999px; background: var(--dm-accent); color: #fff; font-size: 10px; font-weight: 700; }
+.dm-selection-count { border-color: var(--dm-line); background: var(--dm-surface); color: var(--dm-muted); }
+
+/* ── Grid: calmer hairlines + hover, refined sticky header ────────────── */
+.dm-db-grid-wrap { border-color: var(--dm-line); border-radius: var(--dm-radius); }
+.dm-db-grid th { background: var(--dm-surface-soft); color: var(--dm-muted); border-bottom-color: var(--dm-line); border-right-color: var(--dm-line-soft); letter-spacing: .01em; }
+.dm-db-grid td { border-bottom-color: var(--dm-line-soft); border-right-color: var(--dm-line-soft); }
+.dm-db-grid tbody tr:hover td { background: var(--dm-hover); }
+.dm-db-grid tbody tr.selected td { background: var(--dm-accent-soft); box-shadow: inset 2px 0 0 var(--dm-accent); }
+.dm-db-field-type { background: var(--dm-surface-soft); color: var(--dm-faint); border-radius: 5px; }
+
+/* ── Object sidebar: calmer active state (less heavy than solid black) ── */
+.dm-obj-row { border-radius: var(--dm-radius-sm); }
+.dm-obj-row:hover { background: var(--dm-hover); }
+.dm-obj-row.active { background: var(--dm-accent-soft); color: var(--dm-accent); font-weight: 600; }
+.dm-obj-row.active .dm-obj-icon { color: var(--dm-accent); }
+.dm-obj-row.active .dm-badge { background: rgba(79,107,237,.12); color: var(--dm-accent); border-color: var(--dm-accent-line); }
+/* Record count on the live object picker rows (P2). The picker — not the
+   legacy ObjectSidebar — is the rendered object nav. */
+.dm-picker-meta { margin-left: auto; flex: 0 0 auto; color: var(--dm-faint); font-size: 11px; font-weight: 500; font-variant-numeric: tabular-nums; }
+.dm-picker-item.active .dm-picker-meta { color: var(--dm-muted); font-weight: 500; }
+
+/* ── Badges: thinner, calmer ──────────────────────────────────────────── */
+.dm-badge { border-radius: 5px; border-color: var(--dm-line); }
+
+/* ════ Live status chips — shared by StatusPill + run-status work (P4) ══ */
+.dm-status-chip { display: inline-flex; align-items: center; gap: 5px; height: 20px; padding: 0 8px; border: 1px solid var(--dm-line); border-radius: 999px; background: var(--dm-surface-soft); color: var(--dm-muted); font-size: 11px; font-weight: 650; line-height: 1; white-space: nowrap; }
+.dm-status-chip > .dm-status-dot { width: 6px; height: 6px; border-radius: 50%; background: var(--dm-faint); flex: 0 0 auto; }
+.dm-status-chip.is-ok { border-color: var(--dm-ok-line); background: var(--dm-ok-soft); color: #166534; }
+.dm-status-chip.is-ok > .dm-status-dot { background: var(--dm-ok); }
+.dm-status-chip.is-bad { border-color: var(--dm-bad-line); background: var(--dm-bad-soft); color: #991b1b; }
+.dm-status-chip.is-bad > .dm-status-dot { background: var(--dm-bad); }
+.dm-status-chip.is-warn { border-color: var(--dm-warn-line); background: var(--dm-warn-soft); color: #92400e; }
+.dm-status-chip.is-warn > .dm-status-dot { background: var(--dm-warn); }
+.dm-status-chip.is-running { border-color: var(--dm-run-line); background: var(--dm-run-soft); color: #3a4fc0; }
+.dm-status-chip.is-running > .dm-status-dot { background: var(--dm-run); animation: dm-pulse 1.15s ease-in-out infinite; }
+.dm-status-chip.is-waiting > .dm-status-dot { background: var(--dm-faint); }
+@keyframes dm-pulse { 0%,100% { opacity: 1; transform: scale(1); } 50% { opacity: .35; transform: scale(.72); } }
+@media (prefers-reduced-motion: reduce) { .dm-status-chip.is-running > .dm-status-dot { animation: none; } }
+
+/* ── Toggle switch — upgrades ToggleField's checkbox into a real switch ─ */
+.dm-switch-row { display: flex; align-items: flex-start; gap: 10px; cursor: pointer; font-size: 13px; color: var(--dm-ink); }
+.dm-switch-row.is-disabled { opacity: .55; cursor: not-allowed; }
+.dm-switch-row > input { position: absolute; opacity: 0; width: 0; height: 0; }
+.dm-switch-track { position: relative; flex: 0 0 auto; width: 34px; height: 20px; margin-top: 1px; border-radius: 999px; background: #d7dce3; transition: background .14s; }
+.dm-switch-track::after { content: ""; position: absolute; top: 2px; left: 2px; width: 16px; height: 16px; border-radius: 50%; background: #fff; box-shadow: 0 1px 2px rgba(20,28,46,.28); transition: transform .14s; }
+.dm-switch-row > input:checked + .dm-switch-track { background: var(--dm-accent); }
+.dm-switch-row > input:checked + .dm-switch-track::after { transform: translateX(14px); }
+.dm-switch-row > input:focus-visible + .dm-switch-track { box-shadow: 0 0 0 3px var(--dm-accent-soft); }
+.dm-switch-label { display: grid; gap: 2px; }
+.dm-switch-desc { color: var(--dm-muted); font-size: 12px; }
+
+/* ════ Workspace Map / Data Model Canvas (P3) ═════════════════════════════
+   Schema node-canvas reusing the dotted-grid + card language. Read-only. */
+.wm-shell { display: flex; flex-direction: column; min-height: 0; flex: 1; background: var(--dm-surface); }
+.wm-toolbar { display: flex; align-items: center; gap: 10px; padding: 12px 16px; border-bottom: 1px solid var(--dm-line); background: var(--dm-surface); flex-wrap: wrap; }
+.wm-back-link { width: 34px; height: 34px; display: inline-flex; align-items: center; justify-content: center; border: 1px solid var(--dm-line); border-radius: 8px; background: var(--dm-surface); color: var(--dm-muted); text-decoration: none; box-shadow: 0 1px 2px rgba(20,28,46,.04); flex: 0 0 auto; }
+.wm-back-link:hover { background: var(--dm-hover); color: var(--dm-ink); border-color: #cfd6df; }
+.wm-back-link:focus-visible { outline: 2px solid #bfdbfe; outline-offset: 2px; }
+.wm-toolbar h1 { margin: 0; font-size: 15px; font-weight: 650; color: var(--dm-ink); }
+.wm-toolbar .wm-sub { font-size: 12px; color: var(--dm-faint); }
+.wm-legend { display: inline-flex; align-items: center; gap: 12px; margin-left: auto; flex-wrap: wrap; }
+.wm-legend-item { display: inline-flex; align-items: center; gap: 5px; font-size: 11px; color: var(--dm-muted); }
+.wm-legend-swatch { width: 9px; height: 9px; border-radius: 3px; }
+.wm-canvas { position: relative; flex: 1; min-height: 460px; overflow: auto; background-color: #fbfcfd; background-image: radial-gradient(circle, #dde2e8 1px, transparent 1px); background-size: 22px 22px; cursor: grab; touch-action: none; }
+.wm-canvas.is-panning { cursor: grabbing; user-select: none; }
+.wm-canvas-inner { position: relative; }
+.wm-canvas-scale { position: relative; transform-origin: 0 0; }
+.wm-edge { position: absolute; pointer-events: none; }
+.wm-edge path { stroke: #cbd5e1; stroke-width: 1.25; fill: none; stroke-linecap: round; stroke-linejoin: round; }
+.wm-edge .wm-arrow-head { fill: #cbd5e1; stroke: none; }
+.wm-edge path.is-source { stroke: #cbd5e1; }
+.wm-edge path.is-warn { stroke: var(--dm-warn-line); stroke-dasharray: 4 4; }
+.wm-node { position: absolute; width: 220px; border: 1px solid var(--dm-line); border-radius: var(--dm-radius-lg); background: var(--dm-surface); box-shadow: 0 1px 2px rgba(20,28,46,.06); cursor: pointer; transition: box-shadow .12s, border-color .12s, transform .12s; text-align: left; padding: 0; font: inherit; }
+.wm-node:hover { border-color: #cfd6df; box-shadow: var(--dm-shadow-pop); transform: translateY(-1px); }
+.wm-node.is-selected { border-color: var(--dm-accent); box-shadow: 0 0 0 3px var(--dm-accent-soft); }
+.wm-node-head { display: flex; align-items: center; gap: 8px; padding: 10px 12px; border-bottom: 1px solid var(--dm-line-soft); }
+.wm-node-icon { display: inline-flex; align-items: center; justify-content: center; width: 24px; height: 24px; border-radius: 7px; background: var(--dm-surface-soft); color: var(--dm-muted); flex: 0 0 auto; }
+.wm-node-title { flex: 1; min-width: 0; font-size: 13px; font-weight: 650; color: var(--dm-ink); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.wm-node-body { padding: 9px 12px; display: grid; gap: 4px; }
+.wm-node-stat { font-size: 12px; color: var(--dm-muted); font-variant-numeric: tabular-nums; }
+.wm-node-fields { display: flex; flex-wrap: wrap; gap: 4px; margin-top: 2px; }
+.wm-node-field { font-size: 10.5px; color: var(--dm-faint); background: var(--dm-surface-soft); border: 1px solid var(--dm-line-soft); border-radius: 4px; padding: 1px 5px; }
+.wm-node-warn { display: inline-flex; align-items: center; gap: 4px; font-size: 11px; color: var(--dm-warn); }
+.wm-zoom { position: sticky; bottom: 12px; left: 12px; display: inline-flex; gap: 4px; padding: 4px; border: 1px solid var(--dm-line); border-radius: 999px; background: var(--dm-surface); box-shadow: var(--dm-shadow-pop); width: fit-content; margin: 12px; }
+.wm-zoom button { width: 28px; height: 28px; border: 0; border-radius: 999px; background: transparent; color: var(--dm-muted); cursor: pointer; display: inline-flex; align-items: center; justify-content: center; }
+.wm-zoom button:hover { background: var(--dm-hover); color: var(--dm-ink); }
+.wm-empty { display: grid; place-items: center; gap: 8px; padding: 64px 24px; text-align: center; color: var(--dm-muted); }
+.wm-empty strong { font-size: 16px; color: var(--dm-ink); }
+/* Read-only selected-node detail panel — additive, docks top-right of canvas. */
+.wm-detail { position: sticky; top: 12px; margin: -12px 12px 12px auto; float: right; width: 248px; background: var(--dm-surface); border: 1px solid var(--dm-line); border-radius: var(--dm-radius-lg); box-shadow: var(--dm-shadow-pop); z-index: 5; }
+.wm-detail-head { display: flex; align-items: center; gap: 8px; padding: 10px 10px 10px 12px; border-bottom: 1px solid var(--dm-line-soft); }
+.wm-detail-title { flex: 1; min-width: 0; font-size: 13px; font-weight: 650; color: var(--dm-ink); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.wm-detail-close { width: 24px; height: 24px; border: 0; border-radius: 6px; background: transparent; color: var(--dm-faint); cursor: pointer; display: inline-flex; align-items: center; justify-content: center; flex: 0 0 auto; }
+.wm-detail-close:hover { background: var(--dm-hover); color: var(--dm-ink); }
+.wm-detail-meta { margin: 0; padding: 10px 12px; display: grid; gap: 6px; }
+.wm-detail-row { display: flex; justify-content: space-between; gap: 10px; font-size: 12px; }
+.wm-detail-row dt { color: var(--dm-faint); }
+.wm-detail-row dd { margin: 0; color: var(--dm-ink); text-align: right; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.wm-detail-cta { margin: 0 12px 12px; width: calc(100% - 24px); justify-content: center; }
+
+/* Per-node run-status pill on the Workflow Canvas — docked outside the node's
+   top-right corner. Driven by the general orchestration stream
+   (orchestration.node.* deltas) + the persisted nodeTrace; clickable to open
+   the Live Runs trace. */
+.dm-orchestration-node { position: relative; overflow: visible; }
+.dm-orchestration-canvas__step { overflow: visible; }
+.dm-orchestration-node__status { position: absolute; top: -18px; right: 14px; z-index: 3; height: 16px; min-height: 16px; padding: 0 6px; gap: 3px; border: 1px solid var(--dm-line); background: var(--dm-surface); box-shadow: 0 1px 3px rgba(20,28,46,.12); cursor: pointer; font-size: 9.5px; font-weight: 700; line-height: 1; transform: translateY(-2px); }
+.dm-orchestration-node__status > .dm-status-dot { width: 5px; height: 5px; }
+.dm-orchestration-node__status:hover { box-shadow: 0 2px 6px rgba(20,28,46,.2); }
+.dm-orchestration-node__status:focus-visible { outline: 2px solid var(--dm-accent); outline-offset: 1px; }
+
+/* ── Table empty / no-results state (P1) ──────────────────────────────── */
+.dm-db-empty-row td { padding: 0 !important; background: var(--dm-surface) !important; cursor: default !important; }
+.dm-db-empty-row:hover td { background: var(--dm-surface) !important; }
+.dm-db-empty-state { display: grid; justify-items: center; gap: 6px; padding: 48px 24px; text-align: center; }
+.dm-db-empty-state strong { font-size: 15px; color: var(--dm-ink); font-weight: 650; }
+.dm-db-empty-state span { font-size: 12.5px; color: var(--dm-muted); max-width: 360px; }
+.dm-db-empty-actions { display: inline-flex; gap: 8px; margin-top: 8px; }

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

@@ -44,6 +44,7 @@ import {
   validateOrchestrationGraph
 } from "@/lib/orchestration-graph";
 import { resolveConnectorAction } from "@/lib/orchestration-sidecar-routing";
+import { deriveOrchestrationNodeStatuses } from "@/lib/orchestration-node-status";
 import {
   nodeSandboxRecordRef,
   patchSandboxRowInConfig,
@@ -83,6 +84,45 @@ function withUiCacheFlag(workspaceConfig, flag, value) {
   return { ...workspaceConfig, dataModel: { ...dm, objects: nextObjects } };
 }
 
+// Read the sandbox-run NDJSON delta stream (same shape SwarmRunCockpit
+// consumes): push each growthub-sandbox-run-delta-v1 event to `onEvent` for
+// live canvas hydration, and return the sandbox-run.final payload (the run
+// result). Falls back to plain JSON when the response is not a stream.
+async function readSandboxRunStream(response, onEvent) {
+  if (!response?.body || typeof response.body.getReader !== "function") {
+    return response.json().catch(() => null);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let finalPayload = null;
+  const handle = async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.kind !== "growthub-sandbox-run-delta-v1") return;
+      if (event.type === "sandbox-run.final") finalPayload = event.payload || finalPayload;
+      else if (typeof onEvent === "function") {
+        onEvent((prev) => [...prev, event].slice(-300));
+        await new Promise((resolve) => setTimeout(resolve, 90));
+      }
+    } catch {
+      // Ignore malformed cosmetic chunks; the final payload still arrives.
+    }
+  };
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) await handle(line);
+  }
+  if (buffer.trim()) await handle(buffer);
+  return finalPayload;
+}
+
 // Workspace Metadata Graph V1 — read-only dependency metadata for workflow
 // sidecars. The runtime path (sandbox-run, publish, draft/live) is
 // unchanged; this only exposes typed dependency descriptors so the sidecar
@@ -281,6 +321,7 @@ export default function WorkflowSurface() {
   const [publishing, setPublishing] = useState(false);
   const [saveMessage, setSaveMessage] = useState("");
   const [running, setRunning] = useState(false);
+  const [liveRunEvents, setLiveRunEvents] = useState([]);
   const [runMessage, setRunMessage] = useState("");
   const [sidecarMode, setSidecarMode] = useState(runId ? "trace" : "graph");
 
@@ -327,12 +368,29 @@ export default function WorkflowSurface() {
 
   useEffect(() => { load(); }, [load]);
 
+  // Reset live per-node deltas when the active workflow changes, so a prior
+  // run's stream never bleeds onto a different workflow's canvas — the new
+  // workflow settles from its own persisted nodeTrace until it is run.
+  useEffect(() => { setLiveRunEvents([]); }, [objectId, rowId]);
+
   const resolved = useMemo(
     () => (workspaceConfig ? findSandboxRowByWorkflowRef(workspaceConfig, objectId, rowId) : { object: null, row: null, rowIndex: -1 }),
     [workspaceConfig, objectId, rowId]
   );
 
   const sandboxRow = resolved.row;
+
+  // Per-node Workflow Canvas pill status — GENERAL orchestration (not swarm).
+  // Live from the streamed orchestration.node.* deltas while a run is in
+  // flight; settled from the persisted run record's nodeTrace once complete.
+  const runNodeStatuses = useMemo(() => {
+    let record = sandboxRow?.lastResponse;
+    if (typeof record === "string") {
+      try { record = JSON.parse(record); } catch { record = null; }
+    }
+    const map = deriveOrchestrationNodeStatuses({ events: liveRunEvents, record });
+    return Object.keys(map).length ? map : null;
+  }, [liveRunEvents, sandboxRow]);
   const hasGraphValue = (value) => Boolean(parseOrchestrationGraph(value));
   const effectiveFieldName = hasGraphValue(sandboxRow?.[fieldName])
     ? fieldName
@@ -564,17 +622,21 @@ export default function WorkflowSurface() {
       : null;
     setRunning(true);
     setRunMessage("");
+    setLiveRunEvents([]);
     try {
       const draft = await saveDraft({ orchestrationDraftStatus: "testing" });
       const draftGraph = draft?.serialized || serializeCurrentGraph();
-      const body = { objectId, name: rowId, useDraft: true, draftGraph };
+      const body = { objectId, name: rowId, useDraft: true, draftGraph, stream: true };
       if (runInputs) body.runInputs = runInputs;
       const res = await fetch("/api/workspace/sandbox-run", {
         method: "POST",
-        headers: { "content-type": "application/json" },
+        headers: { "content-type": "application/json", accept: "application/x-ndjson" },
         body: JSON.stringify(body),
       });
-      const payload = await res.json();
+      // Consume the NDJSON delta stream: per-node orchestration.node.* events
+      // hydrate the canvas pills live; the sandbox-run.final payload is the
+      // run result we persist. Falls back to plain JSON if not a stream.
+      const payload = (await readSandboxRunStream(res, setLiveRunEvents)) || {};
       const responseText = redactSecretsFromText(JSON.stringify(payload.response ?? payload, null, 2));
       const status = payload.ok && String(payload.status || "").toLowerCase() === "connected" ? "connected" : "failed";
       const pass = isPassingRun(payload);
@@ -1042,6 +1104,8 @@ export default function WorkflowSurface() {
                         setConfigTab("node");
                       }}
                       onConnectorAction={handleConnectorAction}
+                      nodeStatuses={runNodeStatuses}
+                      onNodeStatusClick={(node) => { setSelectedNodeId(String(node?.id || "")); openTraceMode(); }}
                       statusLabel={isDraftMode ? "Draft" : "Live"}
                     />
                     {nextNodeId && (

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

@@ -0,0 +1,14 @@
+"use client";
+
+import { Suspense } from "react";
+import WorkspaceDataModelCanvas from "../data-model/components/WorkspaceDataModelCanvas.jsx";
+
+// Read-only workspace-level schema canvas. No mutation lane, no new runtime —
+// it reads /api/workspace and renders the derived metadata graph.
+export default function WorkspaceMapPage() {
+  return (
+    <Suspense fallback={null}>
+      <WorkspaceDataModelCanvas />
+    </Suspense>
+  );
+}

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

@@ -301,11 +301,43 @@ async function runOrchestrationGraphIfPresent({ workspaceConfig, row, timeoutMs,
   const inputPayload = { ...baseInputPayload, ...manualPayload };
   const consumedInputKeys = Object.keys(manualPayload);
   const transformConfig = extractTransformConfig(graph);
+  const transformNode = (Array.isArray(graph.nodes) ? graph.nodes : [])
+    .find((n) => n?.type === "transform-filter" || n?.type === "normalize-output");
   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];
 
+  // Per-node execution deltas for the GENERAL orchestration pipeline (not
+  // swarm-specific): stream node lifecycle through the same onEvent NDJSON hook
+  // the route already wires, and record a terminal nodeTrace persisted on the
+  // run record. Every event corresponds to a real pipeline stage executing.
+  const onEvent = typeof executionContext?.onEvent === "function" ? executionContext.onEvent : null;
+  const runId = String(executionContext?.runId || "").trim();
+  const nodeTrace = [];
+  const emitNode = (nodeId, status, error) => {
+    const id = String(nodeId || "").trim();
+    if (!id) return;
+    if (status === "completed" || status === "failed" || status === "skipped") {
+      nodeTrace.push(error ? { id, status, error: String(error) } : { id, status });
+    }
+    if (onEvent) {
+      onEvent({
+        kind: "growthub-sandbox-run-delta-v1",
+        type: `orchestration.node.${status}`,
+        nodeId: id,
+        runId,
+        emittedAt: new Date().toISOString(),
+        ...(error ? { error: String(error) } : {})
+      });
+    }
+  };
+
+  // Input stage — payload is assembled above; it ran.
+  if (inputNode?.id) { emitNode(inputNode.id, "started"); emitNode(inputNode.id, "completed"); }
+
+  // API Registry call stage.
+  if (apiNode?.id) emitNode(apiNode.id, "started");
   const raw = await executeApiRegistryCall(
     workspaceConfig,
     apiNode.config,
@@ -320,14 +352,29 @@ async function runOrchestrationGraphIfPresent({ workspaceConfig, row, timeoutMs,
       raw.exitCode = 1;
       raw.error = `HTTP ${httpStatus} is not in successStatusCodes`;
     }
+  }
+
+  if (apiNode?.id) {
+    if (raw.ok) emitNode(apiNode.id, "completed");
+    else emitNode(apiNode.id, "failed", raw.error);
+  }
+
+  if (raw.ok && raw.rawPayload !== undefined) {
+    if (transformNode?.id) emitNode(transformNode.id, "started");
     const transformed = transformProviderPayload(raw.rawPayload, transformConfig);
     raw.stdout = typeof transformed === "string"
       ? transformed
       : normalizeJsonAtPath(transformed, "");
     delete raw.rawPayload;
     delete raw.httpStatus;
+    if (transformNode?.id) emitNode(transformNode.id, "completed");
+    if (resultNode?.id) { emitNode(resultNode.id, "started"); emitNode(resultNode.id, "completed"); }
   } else if (raw.error) {
     raw.error = redactSecretsFromText(raw.error);
+    // Downstream stages never executed → record them as skipped (not-run), not
+    // failed: only the api stage actually failed.
+    if (transformNode?.id) emitNode(transformNode.id, "skipped");
+    if (resultNode?.id) emitNode(resultNode.id, "skipped");
   }
 
   if (raw.stdout) {
@@ -336,6 +383,7 @@ async function runOrchestrationGraphIfPresent({ workspaceConfig, row, timeoutMs,
 
   return {
     ...raw,
+    nodeTrace,
     adapterMeta: {
       ...(raw.adapterMeta || {}),
       orchestrationProvider: graph.provider,

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

@@ -0,0 +1,55 @@
+/**
+ * Orchestration per-node run status — GENERAL (not swarm).
+ *
+ * Maps the real per-node execution signal of a sandbox/orchestration run onto
+ * a plain { nodeId: status } map the Workflow Canvas pills consume:
+ *
+ *   - live:    growthub-sandbox-run-delta-v1 events of type
+ *              `orchestration.node.{started|completed|failed|skipped}` streamed
+ *              from POST /api/workspace/sandbox-run while the run is in flight.
+ *   - settled: the persisted run record's `nodeTrace` (written by the
+ *              orchestration runner) once the run completes.
+ *
+ * This is the general orchestration pipeline signal (input → api-registry-call
+ * → transform → tool-result, human-input, etc.) — distinct from the swarm
+ * cockpit projection. Each entry corresponds to a real pipeline stage that
+ * executed; nothing is fabricated. Pure, never throws.
+ *
+ * Status vocabulary returned: "running" | "completed" | "failed" | "skipped".
+ */
+
+const NODE_EVENT_PREFIX = "orchestration.node.";
+
+function deriveOrchestrationNodeStatuses({ events, record } = {}) {
+  const out = {};
+  try {
+    // Live events win while a run streams — later events overwrite earlier.
+    const list = Array.isArray(events) ? events : [];
+    for (const event of list) {
+      if (!event || typeof event !== "object") continue;
+      if (event.kind && event.kind !== "growthub-sandbox-run-delta-v1") continue;
+      const type = String(event.type || "");
+      if (!type.startsWith(NODE_EVENT_PREFIX)) continue;
+      const id = String(event.nodeId || "").trim();
+      if (!id) continue;
+      const phase = type.slice(NODE_EVENT_PREFIX.length);
+      out[id] = phase === "started" ? "running" : phase;
+    }
+    if (Object.keys(out).length) return out;
+
+    // Settled from the persisted per-node trace.
+    const trace = record && Array.isArray(record.nodeTrace) ? record.nodeTrace : [];
+    for (const entry of trace) {
+      if (!entry || typeof entry !== "object") continue;
+      const id = String(entry.id || "").trim();
+      if (!id) continue;
+      const status = String(entry.status || "").trim();
+      if (status) out[id] = status;
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+export { deriveOrchestrationNodeStatuses };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growthub/cli",
-  "version": "0.14.6",
+  "version": "0.14.8",
   "description": "CLI control plane for Growthub Local and Agent Workspace as Code: export, fork, inspect, operate, sync, and optionally activate governed AI workspaces.",
   "type": "module",
   "bin": {