@growthub/cli 0.14.3 → 0.14.5

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

@@ -298,6 +298,75 @@ const DASHBOARD_TEMPLATES = [
     dashboard: { name: "Blank", status: "draft" },
     widgets: []
   },
+  {
+    id: "ceo-daily-operating",
+    name: "CEO Daily Operating Dashboard",
+    description: "An executive operating surface for the CEO loop: today's focus, the loop scorecard, direct reports, blocked work, reusable Agent Team blueprints, and governance receipts. Companion to the CEO Cockpit (/ceo) — Agent Teams are the atomic config layer, the Fleet is the runtime, and the live next move lives in the cockpit.",
+    category: "reporting",
+    bestFor: ["Founders", "Operators", "Workspace orchestrators"],
+    tags: ["ceo", "operating", "executive", "daily", "agent-teams"],
+    preview: {
+      layout: "operating-grid",
+      summary: "Today's focus, loop scorecard, direct reports, blocked work, Agent Team blueprints, governance receipts, and ritual notes"
+    },
+    dashboard: { name: "CEO Daily Operating Dashboard", status: "draft" },
+    widgets: [
+      createWidget("rich-text", "Today's CEO Focus", { x: 0, y: 0, w: 8, h: 4 }, {
+        text: "Set this each morning: the one highest-leverage move today, what is blocked, what needs review, and what to launch next. The live, computed next move is always in the CEO Cockpit — open it with /ceo.",
+        binding: { mode: "manual", source: "Manual text", rows: [] }
+      }),
+      createWidget("chart", "CEO Loop Scorecard", { x: 8, y: 0, w: 4, h: 4 }, {
+        values: [5, 4, 3, 3, 1, 3],
+        binding: { mode: "manual", source: "Sample — Created · Ready · Launched · Completed · Blocked · Reviewed", rows: [] }
+      }),
+      createWidget("view", "Direct Reports / Swarm Fleet", { x: 0, y: 4, w: 7, h: 5 }, {
+        source: "Sample",
+        layout: "Table",
+        columns: ["Workflow", "State", "Readiness", "Last Outcome", "Next Move"],
+        rows: [
+          { Workflow: "Example research swarm", State: "Completed", Readiness: "Ready", "Last Outcome": "Success", "Next Move": "Review output" },
+          { Workflow: "Example outreach swarm", State: "Not run yet", Readiness: "Ready", "Last Outcome": "—", "Next Move": "Launch" },
+          { Workflow: "Example audit swarm", State: "Blocked", Readiness: "Needs target", "Last Outcome": "—", "Next Move": "Set execution target" }
+        ],
+        binding: { mode: "manual", source: "Sample rows — the live fleet is in the CEO Cockpit (/ceo)", rows: [] }
+      }),
+      createWidget("view", "Blocked or Failing Work", { x: 7, y: 4, w: 5, h: 5 }, {
+        source: "Sample",
+        layout: "Table",
+        columns: ["Workflow", "Blocker", "Severity", "Next Action"],
+        rows: [
+          { Workflow: "Example audit swarm", Blocker: "No execution target", Severity: "High", "Next Action": "Set local adapter" },
+          { Workflow: "Example billing swarm", Blocker: "Last run failed", Severity: "High", "Next Action": "Review + re-run" }
+        ],
+        binding: { mode: "manual", source: "Sample rows — live blockers are in the CEO Cockpit (/ceo)", rows: [] }
+      }),
+      createWidget("view", "Agent Team Blueprints", { x: 0, y: 9, w: 6, h: 4 }, {
+        source: "Sample",
+        layout: "Table",
+        columns: ["Team", "Orchestrator", "Sub-agents", "Outcome"],
+        rows: [
+          { Team: "Research & Synthesis", Orchestrator: "Research Lead", "Sub-agents": "Researcher; Analyst; Synthesizer", Outcome: "Cited brief + recommendation" },
+          { Team: "Outreach", Orchestrator: "Campaign Lead", "Sub-agents": "Writer; Reviewer", Outcome: "Approved sequence" }
+        ],
+        binding: { mode: "manual", source: "Sample blueprints — manage real teams in the Agent Swarm Teams object and launch via /ceo (config layer, not runtime)", rows: [] }
+      }),
+      createWidget("view", "Governance Receipts / Decisions", { x: 6, y: 9, w: 6, h: 4 }, {
+        source: "Sample",
+        layout: "Table",
+        columns: ["Time", "Lane", "Action", "Outcome", "Receipt"],
+        rows: [
+          { Time: "09:14", Lane: "execution-proof", Action: "sandbox-run", Outcome: "completed", Receipt: "rcpt_sample_1" },
+          { Time: "09:31", Lane: "governed-proposal", Action: "helper/apply", Outcome: "applied", Receipt: "rcpt_sample_2" },
+          { Time: "09:42", Lane: "untrusted-direct", Action: "PATCH", Outcome: "blocked", Receipt: "rcpt_sample_3" }
+        ],
+        binding: { mode: "manual", source: "Sample rows — live stream: GET /api/workspace/agent-outcomes", rows: [] }
+      }),
+      createWidget("rich-text", "Daily Ritual Notes", { x: 0, y: 13, w: 12, h: 3 }, {
+        text: "Morning: set today's focus. Midday: launch or review. Afternoon: unblock the failing one first. End of day: confirm the receipts. Define reusable Agent Teams, then launch them as governed swarms — runs land in the Fleet. Open /ceo for the live next move.",
+        binding: { mode: "manual", source: "Manual text", rows: [] }
+      })
+    ]
+  },
   {
     id: "client-portal",
     name: "Client Portal",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growthub/cli",
-  "version": "0.14.3",
+  "version": "0.14.5",
   "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": {
@@ -43,7 +43,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.888.0",
     "@clack/prompts": "^0.10.0",
-    "@growthub/api-contract": "1.5.0",
+    "@growthub/api-contract": "1.5.1",
     "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",
     "better-auth": "1.4.18",

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

@@ -1,141 +0,0 @@
-"use client";
-
-import { Check, ExternalLink, Play, Terminal, X } from "lucide-react";
-import { getApiRegistrySandboxToolState } from "@/lib/orchestration-graph";
-
-export function ApiRegistryActionCard({
-  registryRow,
-  workspaceConfig,
-  disabled,
-  onCreateSandboxTool,
-  onOpenSandboxTool,
-  onRunSandboxTool,
-  onTestConnection,
-  testing,
-  sandboxRunning
-}) {
-  const state = getApiRegistrySandboxToolState(registryRow, workspaceConfig);
-
-  if (state.kind === "incomplete") {
-    const checklist = state.checklist || [];
-    return (
-      <section className="dm-api-action-card dm-api-action-card-muted" aria-label="Complete API setup">
-        <div className="dm-api-action-card-body">
-          <p className="dm-api-action-card-eyebrow">API Registry</p>
-          <h3>Complete API setup</h3>
-          <p>
-            This API needs a registry ID, base URL, endpoint, method, and auth reference before it can become a sandbox tool.
-          </p>
-          <ul className="dm-api-action-checklist">
-            {checklist.map((item) => (
-              <li key={item.field} className={item.ok ? "is-done" : "is-pending"}>
-                {item.ok ? <Check size={14} aria-hidden="true" /> : <X size={14} aria-hidden="true" />}
-                <span>{item.field}</span>
-              </li>
-            ))}
-          </ul>
-        </div>
-      </section>
-    );
-  }
-
-  if (state.kind === "untested") {
-    return (
-      <section className="dm-api-action-card dm-api-action-card-muted" aria-label="Test API first">
-        <div className="dm-api-action-card-body">
-          <p className="dm-api-action-card-eyebrow">Sandbox tool</p>
-          <h3>Test this API first</h3>
-          <p>{state.message}</p>
-        </div>
-        <button
-          type="button"
-          className="dm-btn-primary-sm dm-api-action-card-cta"
-          disabled={disabled || testing}
-          onClick={onTestConnection}
-        >
-          {testing ? "Testing…" : "Test connection"}
-        </button>
-      </section>
-    );
-  }
-
-  if (state.kind === "failed") {
-    return (
-      <section className="dm-api-action-card dm-api-action-card-muted" aria-label="API test failed">
-        <div className="dm-api-action-card-body">
-          <p className="dm-api-action-card-eyebrow">Connection</p>
-          <h3>API test failed</h3>
-          <p>{state.message}</p>
-        </div>
-        <button
-          type="button"
-          className="dm-btn-outline dm-api-action-card-cta"
-          disabled={disabled || testing}
-          onClick={onTestConnection}
-        >
-          {testing ? "Testing…" : "Retest"}
-        </button>
-      </section>
-    );
-  }
-
-  if (state.kind === "existing") {
-    const toolName = String(state.row?.Name || "").trim();
-    return (
-      <section className="dm-api-action-card" aria-label="Sandbox tool ready">
-        <div className="dm-api-action-card-icon" aria-hidden="true">
-          <Terminal size={18} />
-        </div>
-        <div className="dm-api-action-card-body">
-          <p className="dm-api-action-card-eyebrow">Sandbox tool</p>
-          <h3>Sandbox tool ready</h3>
-          <p>{toolName} — governed row linked to this API Registry entry.</p>
-        </div>
-        <div className="dm-api-action-card-actions">
-          <button
-            type="button"
-            className="dm-btn-outline dm-api-action-card-cta"
-            disabled={disabled || !toolName}
-            onClick={() => onOpenSandboxTool?.({ name: toolName })}
-          >
-            <ExternalLink size={14} aria-hidden="true" />
-            Open sandbox tool
-          </button>
-          <button
-            type="button"
-            className="dm-btn-primary-sm dm-api-action-card-cta"
-            disabled={disabled || sandboxRunning || !toolName}
-            onClick={() => onRunSandboxTool?.({ name: toolName })}
-          >
-            <Play size={14} aria-hidden="true" />
-            {sandboxRunning ? "Running…" : "Run sandbox"}
-          </button>
-        </div>
-      </section>
-    );
-  }
-
-  return (
-    <section className="dm-api-action-card" aria-label="Create sandbox tool">
-      <div className="dm-api-action-card-icon" aria-hidden="true">
-        <Terminal size={18} />
-      </div>
-      <div className="dm-api-action-card-body">
-        <p className="dm-api-action-card-eyebrow">API connected</p>
-        <h3>Create sandbox tool</h3>
-        <p>
-          This API is connected. Turn it into a sandbox tool that agents can run safely from this workspace.
-        </p>
-        <p className="dm-api-action-card-note">No secrets are stored. Nothing runs until you test the sandbox.</p>
-      </div>
-      <button
-        type="button"
-        className="dm-btn-primary-sm dm-api-action-card-cta"
-        disabled={disabled}
-        onClick={onCreateSandboxTool}
-      >
-        Create sandbox tool
-      </button>
-    </section>
-  );
-}

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

@@ -1,64 +0,0 @@
-"use client";
-
-import { X } from "lucide-react";
-import { summarizeOrchestrationGraph } from "@/lib/orchestration-graph";
-
-export function SandboxToolConfirmModal({
-  open,
-  toolName,
-  authRef,
-  orchestrationGraph,
-  onConfirm,
-  onCancel,
-  creating
-}) {
-  if (!open) return null;
-
-  const summary = summarizeOrchestrationGraph(orchestrationGraph);
-
-  return (
-    <div className="dm-orchestration-confirm dm-orchestration-confirm__backdrop" onClick={onCancel} role="presentation">
-      <section
-        className="dm-orchestration-confirm__dialog"
-        role="dialog"
-        aria-modal="true"
-        aria-labelledby="sandbox-tool-confirm-title"
-        onClick={(event) => event.stopPropagation()}
-      >
-        <header className="dm-orchestration-confirm__head">
-          <div>
-            <p>Confirm</p>
-            <h2 id="sandbox-tool-confirm-title">Create sandbox tool?</h2>
-          </div>
-          <button type="button" className="dm-sidebar-close" onClick={onCancel} aria-label="Close">
-            <X size={16} />
-          </button>
-        </header>
-        <div className="dm-orchestration-confirm__body">
-          <p>This creates one Sandbox Environment row from the tested API Registry record.</p>
-          <ul className="dm-orchestration-confirm__list">
-            <li>Saves orchestrationGraph on the sandbox row</li>
-            <li>Stores <code>{authRef || "authRef"}</code> only — no secrets</li>
-            <li>Does not store secrets</li>
-            <li>Does not create widgets</li>
-            <li>Does not change dashboards</li>
-            <li>Does not change canvas</li>
-            <li>Does not run until you click Run sandbox</li>
-          </ul>
-          <p className="dm-orchestration-confirm__summary">
-            <span>Run plan</span>
-            {summary}
-          </p>
-        </div>
-        <footer className="dm-orchestration-confirm__foot">
-          <button type="button" className="dm-btn-outline" disabled={creating} onClick={onCancel}>
-            Cancel
-          </button>
-          <button type="button" className="dm-btn-primary-sm" disabled={creating} onClick={onConfirm}>
-            {creating ? "Creating…" : "Create tool"}
-          </button>
-        </footer>
-      </section>
-    </div>
-  );
-}

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

@@ -1,376 +0,0 @@
-"use client";
-
-import { useEffect, useMemo, useState } from "react";
-import { ArrowLeft } from "lucide-react";
-import {
-  addCanonicalNodeToGraph,
-  buildBlankOrchestrationGraphShell,
-  buildDefaultOrchestrationGraphFromRegistry,
-  getNextCanonicalNodeId,
-  isApiRegistryTestSuccessful,
-  getOrchestrationGraphUiState,
-  parseOrchestrationGraph,
-  serializeOrchestrationGraph,
-  updateGraphNode,
-  validateOrchestrationGraph
-} from "@/lib/orchestration-graph";
-import { resolveConnectorAction } from "@/lib/orchestration-sidecar-routing";
-import { OrchestrationGraphCanvas } from "./OrchestrationGraphCanvas.jsx";
-import { OrchestrationGraphEmptyCanvas } from "./OrchestrationGraphEmptyCanvas.jsx";
-import { OrchestrationNodeConfigPanel } from "./OrchestrationNodeConfigPanel.jsx";
-
-export function SandboxToolDraftPanel({
-  registryRow,
-  draftOptions,
-  onDraftChange,
-  onRequestConfirm,
-  onCancel,
-  disabled
-}) {
-  const integrationId = String(registryRow?.integrationId || "").trim();
-  const registryName = String(registryRow?.Name || integrationId).trim();
-  const defaultName = registryRow?.Name
-    ? `${String(registryRow.Name).trim()} Tool`
-    : `${integrationId} Tool`;
-
-  const [name, setName] = useState(draftOptions?.name || defaultName);
-  const [description, setDescription] = useState(draftOptions?.description || String(registryRow?.description || "").trim());
-  const [runLocality, setRunLocality] = useState(draftOptions?.runLocality || "local");
-  const [adapter, setAdapter] = useState(draftOptions?.adapter || "local-process");
-  const [authRef, setAuthRef] = useState(draftOptions?.authRef || String(registryRow?.authRef || integrationId).trim());
-  const [envRefs, setEnvRefs] = useState(draftOptions?.envRefs || "");
-  const [networkAllow, setNetworkAllow] = useState(Boolean(draftOptions?.networkAllow));
-  const [timeoutMs, setTimeoutMs] = useState(String(draftOptions?.timeoutMs || "30000"));
-  const [rootPath, setRootPath] = useState(draftOptions?.rootPath || "data");
-  const [instructions, setInstructions] = useState(draftOptions?.instructions || "");
-  const [agentHost, setAgentHost] = useState(draftOptions?.agentHost || "");
-  const [schedulerRegistryId, setSchedulerRegistryId] = useState(
-    draftOptions?.schedulerRegistryId || (draftOptions?.runLocality === "serverless" ? integrationId : "")
-  );
-  const [selectedNodeId, setSelectedNodeId] = useState("input");
-  const [configTab, setConfigTab] = useState("node");
-  const [graphError, setGraphError] = useState("");
-  const [orchestrationGraph, setOrchestrationGraph] = useState(() => {
-    if (draftOptions?.orchestrationGraph) {
-      return parseOrchestrationGraph(draftOptions.orchestrationGraph);
-    }
-    return null;
-  });
-
-  const registryKey = `${integrationId}:${String(registryRow?.endpoint || "")}:${String(registryRow?.method || "")}`;
-  const graphUiState = getOrchestrationGraphUiState(orchestrationGraph);
-  const graphUnset = graphUiState === "unset";
-  const graphBlankShell = graphUiState === "blank-shell";
-  const nextNodeId = useMemo(
-    () => (orchestrationGraph ? getNextCanonicalNodeId(orchestrationGraph) : "input"),
-    [orchestrationGraph]
-  );
-
-  useEffect(() => {
-    if (graphUnset || graphBlankShell) return;
-    setOrchestrationGraph((current) => {
-      const base = buildDefaultOrchestrationGraphFromRegistry(registryRow, {
-        label: registryName,
-        authRef,
-        rootPath
-      });
-      const parsed = parseOrchestrationGraph(current) || current;
-      if (!parsed?.nodes?.length) return current;
-      return {
-        ...parsed,
-        nodes: parsed.nodes.map((node) => {
-          const template = base.nodes.find((n) => n.id === node.id);
-          if (!template) return node;
-          if (node.id === "api-request") {
-            return {
-              ...node,
-              subtitle: template.subtitle,
-              config: { ...template.config, ...node.config, authRef }
-            };
-          }
-          if (node.id === "transform") {
-            return { ...node, config: { ...node.config, rootPath } };
-          }
-          return node;
-        })
-      };
-    });
-  }, [registryKey, registryName, authRef, rootPath, registryRow, integrationId, graphUnset, graphBlankShell]);
-
-  const selectedNode = useMemo(() => {
-    const parsed = parseOrchestrationGraph(orchestrationGraph) || orchestrationGraph;
-    if (!selectedNodeId || !parsed?.nodes) return null;
-    return parsed.nodes.find((n) => String(n.id) === selectedNodeId) || null;
-  }, [orchestrationGraph, selectedNodeId]);
-
-  const graphSerialized = useMemo(
-    () => (graphUnset ? "" : serializeOrchestrationGraph(orchestrationGraph)),
-    [orchestrationGraph, graphUnset]
-  );
-
-  useEffect(() => {
-    if (graphUnset || graphBlankShell) {
-      setGraphError(graphBlankShell ? "Add at least Input and API Registry nodes before creating." : "");
-    } else {
-      const validation = validateOrchestrationGraph(orchestrationGraph);
-      setGraphError(validation.ok ? "" : validation.errors[0] || "Invalid graph");
-    }
-    onDraftChange?.({
-      name,
-      description,
-      runLocality,
-      adapter,
-      authRef,
-      envRefs,
-      networkAllow,
-      timeoutMs,
-      rootPath,
-      instructions,
-      agentHost,
-      schedulerRegistryId,
-      orchestrationGraph: graphSerialized
-    });
-  }, [
-    name,
-    description,
-    runLocality,
-    adapter,
-    authRef,
-    envRefs,
-    networkAllow,
-    timeoutMs,
-    rootPath,
-    instructions,
-    agentHost,
-    schedulerRegistryId,
-    graphSerialized,
-    orchestrationGraph,
-    graphUnset,
-    graphBlankShell,
-    onDraftChange
-  ]);
-
-  function startFromRegistry() {
-    setOrchestrationGraph(buildDefaultOrchestrationGraphFromRegistry(registryRow, { authRef, rootPath }));
-    setSelectedNodeId("input");
-    setConfigTab("node");
-  }
-
-  function startBlank() {
-    setOrchestrationGraph(buildBlankOrchestrationGraphShell());
-    setSelectedNodeId("input");
-    setConfigTab("node");
-  }
-
-  function applyPastedGraph(text) {
-    const parsed = parseOrchestrationGraph(text);
-    if (parsed) setOrchestrationGraph(parsed);
-  }
-
-  function addNextNode() {
-    if (!nextNodeId) return;
-    setOrchestrationGraph((g) => addCanonicalNodeToGraph(
-      g || buildBlankOrchestrationGraphShell(),
-      nextNodeId,
-      registryRow,
-      { authRef, rootPath }
-    ));
-    setSelectedNodeId(nextNodeId);
-    setConfigTab("node");
-  }
-
-  function handleNodeConfigChange(configPatch) {
-    if (!selectedNodeId) return;
-    setOrchestrationGraph((g) => updateGraphNode(g, selectedNodeId, configPatch));
-    if (selectedNodeId === "transform" && configPatch.rootPath) {
-      setRootPath(String(configPatch.rootPath));
-    }
-  }
-
-  function handleConnectorAction(payload) {
-    const { nodeId, tab } = resolveConnectorAction(payload);
-    setSelectedNodeId(nodeId);
-    setConfigTab(tab);
-  }
-
-  const defaultInstructions = `Governed sandbox tool for ${registryName}. Calls ${String(registryRow?.method || "GET").toUpperCase()} ${registryRow?.endpoint || registryRow?.baseUrl || ""}. authRef ${authRef} only — secrets resolve server-side.`;
-  const headerBadge = isApiRegistryTestSuccessful(registryRow) ? "connected" : "draft";
-  const canCreate = graphUiState === "populated" && !graphError && isApiRegistryTestSuccessful(registryRow);
-
-  return (
-    <section className="dm-orchestration-sidecar" aria-label="Sandbox orchestration field editor">
-      <header className="dm-orchestration-header">
-        <button type="button" className="dm-orchestration-header__back" onClick={onCancel} aria-label="Back">
-          <ArrowLeft size={16} />
-        </button>
-        <div className="dm-orchestration-header__titles">
-          <h2>Sandbox tool draft</h2>
-          <p>Created from {registryName}</p>
-        </div>
-        <span className={`dm-orchestration-header__badge is-${headerBadge}`}>{headerBadge}</span>
-        <div className="dm-orchestration-header__actions">
-          <button type="button" className="dm-btn-outline" disabled={disabled} onClick={onCancel}>
-            Cancel
-          </button>
-          <button
-            type="button"
-            className="dm-btn-primary-sm"
-            disabled={disabled || !name.trim() || !canCreate}
-            onClick={onRequestConfirm}
-          >
-            Create tool
-          </button>
-        </div>
-      </header>
-
-      <div className="dm-orchestration-sidecar__body">
-        <div className="dm-orchestration-sidecar__canvas-col">
-          {graphUnset ? (
-            <OrchestrationGraphEmptyCanvas
-              disabled={disabled}
-              onStartFromRegistry={startFromRegistry}
-              onStartBlank={startBlank}
-              onPasteGraph={applyPastedGraph}
-            />
-          ) : graphBlankShell ? (
-            <div className="dm-orchestration-canvas dm-orchestration-canvas--blank-shell">
-              <p className="dm-orchestration-canvas__blank-hint">Add first node</p>
-              <button type="button" className="dm-btn-outline" disabled={disabled} onClick={addNextNode}>
-                + Add Input
-              </button>
-            </div>
-          ) : (
-            <>
-              <OrchestrationGraphCanvas
-                graph={orchestrationGraph}
-                selectedNodeId={selectedNodeId}
-                onSelectNode={(node) => {
-                  setSelectedNodeId(String(node?.id || ""));
-                  setConfigTab("node");
-                }}
-                onConnectorAction={handleConnectorAction}
-              />
-              {nextNodeId && (
-                <button
-                  type="button"
-                  className="dm-btn-outline dm-orchestration-canvas__add-node"
-                  disabled={disabled}
-                  onClick={addNextNode}
-                >
-                  + Add {nextNodeId === "api-request" ? "API Registry" : nextNodeId === "transform" ? "Transform" : nextNodeId === "result" ? "Result" : "Input"}
-                </button>
-              )}
-            </>
-          )}
-        </div>
-
-        <div className="dm-orchestration-sidecar__config-col">
-          {graphUiState === "populated" && (
-            <OrchestrationNodeConfigPanel
-              node={selectedNode}
-              registryRow={registryRow}
-              disabled={disabled}
-              activeTab={configTab}
-              onTabChange={setConfigTab}
-              onConfigChange={handleNodeConfigChange}
-            />
-          )}
-
-          <details className="dm-orchestration-runtime">
-            <summary>Runtime (sandbox row)</summary>
-            <div className="dm-orchestration-runtime__fields">
-              <label className="dm-orchestration-config__field">
-                <span>Name</span>
-                <input value={name} disabled={disabled} onChange={(e) => setName(e.target.value)} />
-              </label>
-              <label className="dm-orchestration-config__field">
-                <span>Description</span>
-                <textarea rows={2} value={description} disabled={disabled} onChange={(e) => setDescription(e.target.value)} />
-              </label>
-              <label className="dm-orchestration-config__field">
-                <span>Run locality</span>
-                <select
-                  value={runLocality}
-                  disabled={disabled}
-                  onChange={(e) => {
-                    const next = e.target.value;
-                    setRunLocality(next);
-                    setAdapter(next === "serverless" ? "serverless" : "local-process");
-                    if (next === "serverless" && !schedulerRegistryId) {
-                      setSchedulerRegistryId(integrationId);
-                    }
-                  }}
-                >
-                  <option value="local">local</option>
-                  <option value="serverless">serverless</option>
-                </select>
-              </label>
-              <label className="dm-orchestration-config__field">
-                <span>Adapter</span>
-                <select value={adapter} disabled={disabled} onChange={(e) => setAdapter(e.target.value)}>
-                  <option value="local-process">local-process</option>
-                  <option value="local-agent-host">local-agent-host</option>
-                  <option value="serverless">serverless</option>
-                </select>
-              </label>
-              {adapter === "local-agent-host" && (
-                <label className="dm-orchestration-config__field">
-                  <span>Agent host</span>
-                  <input value={agentHost} disabled={disabled} onChange={(e) => setAgentHost(e.target.value)} />
-                </label>
-              )}
-              {runLocality === "serverless" && (
-                <label className="dm-orchestration-config__field">
-                  <span>Scheduler registry ID</span>
-                  <input
-                    value={schedulerRegistryId}
-                    disabled={disabled}
-                    onChange={(e) => setSchedulerRegistryId(e.target.value)}
-                  />
-                </label>
-              )}
-              <label className="dm-orchestration-config__field">
-                <span>Auth reference</span>
-                <input value={authRef} disabled={disabled} onChange={(e) => setAuthRef(e.target.value)} />
-              </label>
-              <label className="dm-orchestration-config__field dm-orchestration-config__field-inline">
-                <input
-                  type="checkbox"
-                  checked={networkAllow}
-                  disabled={disabled}
-                  onChange={(e) => setNetworkAllow(e.target.checked)}
-                />
-                <span>Network allowed</span>
-              </label>
-              <label className="dm-orchestration-config__field">
-                <span>Env refs (comma-separated)</span>
-                <input value={envRefs} disabled={disabled} onChange={(e) => setEnvRefs(e.target.value)} />
-              </label>
-              <label className="dm-orchestration-config__field">
-                <span>Timeout (ms)</span>
-                <input value={timeoutMs} disabled={disabled} onChange={(e) => setTimeoutMs(e.target.value)} />
-              </label>
-              <label className="dm-orchestration-config__field">
-                <span>Instructions</span>
-                <textarea
-                  rows={3}
-                  value={instructions || defaultInstructions}
-                  disabled={disabled}
-                  onChange={(e) => setInstructions(e.target.value)}
-                />
-              </label>
-            </div>
-          </details>
-
-          {graphError && <p className="dm-orchestration-config__error">{graphError}</p>}
-          {graphUnset && (
-            <p className="dm-orchestration-config__hint">Start a graph before creating the sandbox tool.</p>
-          )}
-          <p className="dm-orchestration-sidecar__footnote">
-            No secrets are stored. Nothing runs until you click Run sandbox after creation.
-          </p>
-        </div>
-      </div>
-    </section>
-  );
-}