@growthub/cli 0.14.3 → 0.14.4

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

@@ -0,0 +1,206 @@
+/**
+ * CEO cockpit projection — the governed "chief orchestrator" oversight lens
+ * over the existing agent-swarm fleet (GOVERNED_COCKPIT_ENTRY_POINT_PATTERN_V1
+ * + CEO_PRIMITIVE_COCKPIT_ROADMAP_V1).
+ *
+ * This is a PURE deriver — no React, no fetch, no fs, no config writes, no
+ * localStorage, no CSS. It takes the workspace config (and, optionally, the
+ * agent-outcomes receipt stream) and emits a low-entropy view-model the
+ * CeoCockpit component renders. It introduces NO new governed object, NO new
+ * API, NO new PATCH field: the CEO oversees the same `sandbox-environment`
+ * swarm-workflows the Background Tasks cockpit executes, and every "Open"
+ * routes back into that existing surface.
+ *
+ * Causation ITT shape (state -> eligibility -> guidance -> action): each swarm
+ * workflow is a "direct report"; its run evidence + execution eligibility
+ * derive a state, a human headline, and the single next action — and the fleet
+ * rolls those up into one "needs your attention" pick so the CEO always knows
+ * the next move without reading logs.
+ *
+ * Data sources (all already in the contract):
+ *   - findSwarmRunRows(config)                       — the governed fleet
+ *   - deriveSwarmWorkflowExecutionEligibility(entry) — the existing readiness gate
+ *   - deriveSwarmRunProjection(row.lastResponse)     — the existing run projection
+ *   - workspace:agent-outcomes receipts (optional)   — governance rollup only
+ */
+
+import { deriveSwarmRunProjection } from "./orchestration-run-console.js";
+import {
+  findSwarmRunRows,
+  deriveSwarmWorkflowExecutionEligibility,
+} from "./workspace-swarm-proposal.js";
+
+// Parse the latest persisted run record off a swarm row. Mirrors the
+// SwarmRunCockpit fallback exactly — row.lastResponse is the durable record
+// when run history has not been re-fetched.
+function parseRowRecord(row) {
+  const raw = row?.lastResponse;
+  if (!raw) return null;
+  if (typeof raw === "object") return raw;
+  try {
+    return JSON.parse(String(raw));
+  } catch {
+    return null;
+  }
+}
+
+// Map a report state to the inherited run-console dot variant grammar
+// (ok | fail | active | pending | canceled) — no new visual vocabulary.
+function variantForState(state) {
+  switch (state) {
+    case "completed": return "ok";
+    case "failing": return "fail";
+    case "running": return "active";
+    case "blocked": return "canceled";
+    case "never-run":
+    default: return "pending";
+  }
+}
+
+// Next-action label per state — the CEO's verb, never a hidden flag.
+function nextActionLabel(state) {
+  switch (state) {
+    case "blocked": return "Fix execution target";
+    case "failing": return "Review failed run";
+    case "never-run": return "Open to launch";
+    case "running": return "Open running task";
+    case "completed":
+    default: return "Open task";
+  }
+}
+
+// Classify one swarm workflow into exactly one report state. Blocked
+// (no runnable execution target) takes priority because nothing else is
+// actionable until it clears — the same truth the Play gate enforces.
+function classifyReport(eligibility, projection) {
+  if (!eligibility?.ready) return "blocked";
+  const status = projection?.status;
+  if (status === "failed") return "failing";
+  if (status === "running" || status === "executing") return "running";
+  if (status === "completed") return "completed";
+  return "never-run";
+}
+
+// Human one-liner for a report card — plain language, no jargon.
+function headlineForState(state, eligibility, agentCount) {
+  switch (state) {
+    case "blocked":
+      return eligibility?.guidance || "Set an execution target before this can run.";
+    case "failing":
+      return "Last run failed — review the transcript and re-run.";
+    case "running":
+      return "Running now — open to watch progress.";
+    case "completed":
+      return `Completed · ${agentCount} agent${agentCount === 1 ? "" : "s"}.`;
+    case "never-run":
+    default:
+      return `Ready · ${agentCount} agent${agentCount === 1 ? "" : "s"} · not run yet.`;
+  }
+}
+
+// Attention priority: a CEO looks at what is broken first, then what is
+// blocked, then what has never shipped. Healthy fleets surface nothing.
+const ATTENTION_PRIORITY = ["failing", "blocked", "never-run"];
+
+/**
+ * Build the CEO cockpit view-model.
+ *
+ * @param {object} args
+ * @param {object} args.workspaceConfig  live workspace config (GET /api/workspace)
+ * @param {Array}  [args.receipts]       workspace:agent-outcomes stream (optional)
+ * @returns {object} view-model — see module header.
+ */
+export function deriveCeoCockpit({ workspaceConfig, receipts = [] } = {}) {
+  const entries = findSwarmRunRows(workspaceConfig);
+  const safeReceipts = Array.isArray(receipts) ? receipts : [];
+
+  const reports = entries.map((entry, index) => {
+    const eligibility = deriveSwarmWorkflowExecutionEligibility(entry);
+    const record = parseRowRecord(entry.row);
+    const projection = record ? deriveSwarmRunProjection(record) : null;
+    const state = classifyReport(eligibility, projection);
+    const agentCount = Number.isFinite(Number(projection?.agentCount))
+      ? Number(projection.agentCount)
+      : Number(eligibility?.runnableNodeCount) || 0;
+    const name = String(entry.row?.Name || "").trim();
+    // Stable, collision-proof identity: object + row id (or Name) + index.
+    // Two workflows that share a Name still get distinct reportIds, so the
+    // attention filter and React keys never drop or merge a record.
+    const rowKey = String(entry.row?.id || name || `row-${index}`).trim();
+    const reportId = `${entry.objectId}::${rowKey}::${index}`;
+    const lastRun = projection
+      ? {
+          status: projection.status,
+          runId: projection.runId || null,
+          totalTokens: projection.totalTokens ?? null,
+          totalTools: projection.totalTools ?? null,
+          elapsedMs: projection.elapsedMs ?? null,
+        }
+      : null;
+
+    return {
+      reportId,
+      objectId: entry.objectId,
+      name,
+      objectLabel: entry.objectLabel || null,
+      lifecycleStatus: String(entry.row?.lifecycleStatus || "draft"),
+      version: String(entry.row?.version || "1"),
+      agentCount,
+      state,
+      variant: variantForState(state),
+      readiness: {
+        ready: eligibility.ready,
+        status: eligibility.status,
+        missing: eligibility.missing,
+        guidance: eligibility.guidance,
+        adapter: eligibility.adapter,
+        agentHost: eligibility.agentHost,
+      },
+      lastRun,
+      headline: headlineForState(state, eligibility, agentCount),
+      nextAction: {
+        label: nextActionLabel(state),
+        // Routes through the EXISTING swarm-run artifact surface — the CEO
+        // cockpit never executes; it hands off to Background Tasks.
+        artifact: name ? { surface: "swarm-run", objectId: entry.objectId, name } : null,
+      },
+    };
+  });
+
+  const countOf = (state) => reports.filter((r) => r.state === state).length;
+  const fleet = {
+    total: reports.length,
+    runnable: reports.filter((r) => r.readiness.ready).length,
+    blocked: countOf("blocked"),
+    failing: countOf("failing"),
+    neverRun: countOf("never-run"),
+    running: countOf("running"),
+    completed: countOf("completed"),
+  };
+
+  // The single next move for the CEO — the highest-priority report, or null
+  // when the fleet is healthy. This is the causation "next action".
+  let attention = null;
+  for (const state of ATTENTION_PRIORITY) {
+    const hit = reports.find((r) => r.state === state);
+    if (hit) { attention = hit; break; }
+  }
+
+  // Governance rollup is a pure read over the receipt stream — blocked
+  // mutation/execution attempts the CEO should be aware of. Zeroed when no
+  // receipts were supplied (the cockpit still renders the fleet).
+  const blockedAttempts = safeReceipts.filter(
+    (r) => r && r.outcomeStatus === "blocked"
+  ).length;
+
+  return {
+    title: "CEO Cockpit",
+    fleet,
+    attention,
+    reports,
+    governance: { blockedAttempts },
+    generatedFromReceipts: safeReceipts.length > 0,
+  };
+}
+
+export default deriveCeoCockpit;

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

@@ -241,7 +241,9 @@ function checkSandboxRow(row, currentRow, path, violations) {
 
   const incomingStatus = String(row.lifecycleStatus ?? "").trim().toLowerCase();
   const currentStatus = String(currentRow?.lifecycleStatus ?? "").trim().toLowerCase();
+  const isHelperSetupRow = rowName(row) === "workspace-helper";
   if (incomingStatus === "live" && currentStatus !== "live") {
+    if (isHelperSetupRow) return;
     violations.push(violation(
       "live_publish_via_patch",
       `${path}.lifecycleStatus`,

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.4",
   "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": {