@growthub/cli 0.13.6 → 0.13.8

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

@@ -11,8 +11,8 @@
  * Execution model:
  *   1. Read and sanitize the live growthub.config.json (or accept a snapshot).
  *   2. Build a workspace-grammar-injected system prompt via workspace-helper.js.
- *   3. Dispatch through the local-intelligence sandbox adapter.
- *   4. Parse the growthub-local-model-sandbox-v1 envelope.
+ *   3. Dispatch through the configured workspace-helper-sandbox adapter.
+ *   4. Parse the helper JSON envelope.
  *   5. Validate proposals, write a run record to source-records, return response.
  *
  * Request body (WorkspaceHelperQuery):
@@ -73,11 +73,38 @@ const VALID_INTENTS = [
 ];
 
 const HELPER_SOURCE_KEY_PREFIX = "helper";
+const HELPER_SANDBOX_OBJECT_ID = "workspace-helper-sandbox";
 
 function helperSourceId(intent, runId) {
   return `${HELPER_SOURCE_KEY_PREFIX}:${intent}:${runId}`;
 }
 
+function findHelperSandboxRow(config) {
+  const objects = Array.isArray(config?.dataModel?.objects) ? config.dataModel.objects : [];
+  const helperObject = objects.find((o) => o?.id === HELPER_SANDBOX_OBJECT_ID && o?.objectType === "sandbox-environment");
+  const rows = Array.isArray(helperObject?.rows) ? helperObject.rows : [];
+  return rows[0] && typeof rows[0] === "object" ? rows[0] : null;
+}
+
+function buildAgentHostCommand(messages) {
+  const transcript = messages
+    .map((message) => {
+      const role = typeof message?.role === "string" ? message.role.toUpperCase() : "MESSAGE";
+      const content = typeof message?.content === "string" ? message.content : "";
+      return `### ${role}\n${content}`;
+    })
+    .join("\n\n");
+
+  return [
+    "You are the Growthub Workspace Helper running through the user's selected local agent host.",
+    "Use the full transcript below. Return only one JSON object with this exact shape:",
+    JSON.stringify({ summary: "", proposals: [], warnings: [] }),
+    "Do not wrap the JSON in markdown. Do not execute tools or mutate files.",
+    "",
+    transcript,
+  ].join("\n");
+}
+
 async function POST(request) {
   let body;
   try {
@@ -117,6 +144,13 @@ async function POST(request) {
     snapshot = sanitizeWorkspaceSnapshot(liveConfig);
     liveConfigForThread = liveConfig;
   }
+  if (!liveConfigForThread) {
+    try {
+      liveConfigForThread = await readWorkspaceConfig();
+    } catch {
+      liveConfigForThread = null;
+    }
+  }
 
   // Thread continuity — pull prior messages from the governed helper-threads
   // row when the caller supplied a threadId so the chat completion gets the
@@ -170,12 +204,17 @@ async function POST(request) {
   const userIntent = userPrompt;
 
   await ensureSandboxAdaptersLoaded();
-  const adapter = getSandboxAdapter("local-intelligence");
+  const helperSandboxRow = findHelperSandboxRow(liveConfigForThread);
+  const helperAdapterId = String(helperSandboxRow?.adapter || "").trim();
+  const helperAgentHost = String(helperSandboxRow?.agentHost || "").trim();
+  const useAgentHost = helperAdapterId === "local-agent-host" && helperAgentHost;
+  const adapterId = useAgentHost ? "local-agent-host" : "local-intelligence";
+  const adapter = getSandboxAdapter(adapterId);
   if (!adapter) {
     return NextResponse.json(
       {
         ok: false,
-        error: "local-intelligence adapter not registered. Ensure sandbox adapters are loaded.",
+        error: `${adapterId} adapter not registered. Ensure sandbox adapters are loaded.`,
       },
       { status: 503 }
     );
@@ -186,32 +225,50 @@ async function POST(request) {
 
   let adapterResult;
   try {
-    adapterResult = await adapter.run({
-      runId,
-      name: `workspace-helper-${resolvedIntent}`,
-      runtime: "node",
-      agentHost: "",
-      command: userIntent,
-      timeoutMs: 90000,
-      networkAllow: true,
-      allowList: [],
-      env: {},
-      envRefSlugs: [],
-      envRefsMissing: [],
-      workdir: "/tmp",
-      ranAt,
-      intelligenceSandbox: {
-        // Structured multi-turn message array — the adapter passes this
-        // straight through to the chat completions endpoint so the model
-        // sees the full conversation history with stable system prefix
-        // (KV-cache friendly).
-        messages: chatMessages,
-        userIntent,
-        localModel: modelOverride || process.env.NATIVE_INTELLIGENCE_LOCAL_MODEL || process.env.OLLAMA_MODEL || "gemma3:4b",
-        localEndpoint: localEndpointOverride || "",
-        intelligenceAdapterMode: adapterModeOverride || "ollama",
-      },
-    });
+    if (useAgentHost) {
+      adapterResult = await adapter.run({
+        runId,
+        name: `workspace-helper-${resolvedIntent}`,
+        runtime: "node",
+        agentHost: helperAgentHost,
+        command: buildAgentHostCommand(chatMessages),
+        timeoutMs: Number(helperSandboxRow?.timeoutMs) || 120000,
+        networkAllow: true,
+        allowList: [],
+        env: {},
+        envRefSlugs: [],
+        envRefsMissing: [],
+        workdir: "/tmp",
+        ranAt,
+      });
+    } else {
+      adapterResult = await adapter.run({
+        runId,
+        name: `workspace-helper-${resolvedIntent}`,
+        runtime: "node",
+        agentHost: "",
+        command: userIntent,
+        timeoutMs: 90000,
+        networkAllow: true,
+        allowList: [],
+        env: {},
+        envRefSlugs: [],
+        envRefsMissing: [],
+        workdir: "/tmp",
+        ranAt,
+        intelligenceSandbox: {
+          // Structured multi-turn message array — the adapter passes this
+          // straight through to the chat completions endpoint so the model
+          // sees the full conversation history with stable system prefix
+          // (KV-cache friendly).
+          messages: chatMessages,
+          userIntent,
+          localModel: modelOverride || process.env.NATIVE_INTELLIGENCE_LOCAL_MODEL || process.env.OLLAMA_MODEL || "gemma3:4b",
+          localEndpoint: localEndpointOverride || "",
+          intelligenceAdapterMode: adapterModeOverride || "ollama",
+        },
+      });
+    }
   } catch (err) {
     return NextResponse.json(
       {
@@ -226,10 +283,10 @@ async function POST(request) {
     return NextResponse.json(
       {
         ok: false,
-        error: adapterResult.error || "local-intelligence adapter returned error",
+        error: adapterResult.error || `${adapterId} adapter returned error`,
         receipts: {
-          model: "unknown",
-          adapterMode: adapterModeOverride || "ollama",
+          model: useAgentHost ? helperAgentHost : "unknown",
+          adapterMode: useAgentHost ? "agent-host" : (adapterModeOverride || "ollama"),
           endpoint: "",
           confidence: 0,
           latencyMs: adapterResult.durationMs || 0,
@@ -241,7 +298,14 @@ async function POST(request) {
     );
   }
 
-  const parsed = parseHelperEnvelope(adapterResult.stdout, intent);
+  const parsedInput = useAgentHost
+    ? {
+        result: { text: adapterResult.stdout },
+        adapter: { mode: "agent-host", modelId: helperAgentHost, endpoint: "local-agent-host" },
+        latencyMs: adapterResult.durationMs || 0,
+      }
+    : adapterResult.stdout;
+  const parsed = parseHelperEnvelope(parsedInput, intent);
   const { valid: validProposals, errors: validationErrors } = validateProposals(parsed.proposals);
 
   const warnings = [...parsed.warnings];

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

@@ -152,6 +152,7 @@ async function GET(request) {
       runs: metadataStore.runs,
       outputArtifacts: metadataStore.outputArtifacts,
       workerKits: metadataStore.workerKits,
+      provenance: metadataStore.provenance,
       pipelineHealth: metadataStore.pipelineHealth
     },
     graph: {

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

@@ -0,0 +1,106 @@
+/**
+ * GET /api/workspace/swarm-condition
+ *
+ * Growthub Workspace Swarm Condition Packet V1 — read-only projection.
+ *
+ * Composes a registered workspace state lens into the agent-swarm assignment
+ * shape: instead of a vague prompt, an agent (or a swarm) gets a workspace
+ * *condition* — goal, current state, the blocked step, its prerequisite, the
+ * tools available, and the evidence it must produce. The human activation
+ * panel and this packet read the identical derived state.
+ *
+ * Optional query parameter:
+ *   - lensId: "activation" (default) | "persistence" | "observability" |
+ *             "deploy" | "tasks" | "app-build". Unknown ids fall back to
+ *             "activation".
+ *
+ * Authority invariants:
+ *   - GET only. PATCH / POST / PUT / DELETE are not exposed. Writes still flow
+ *     through the existing governed routes (`PATCH /api/workspace`,
+ *     `POST /api/workspace/sandbox-run`, etc.).
+ *   - growthub.config.json remains the authoritative artifact.
+ *   - No secrets, connection IDs, or tokens are returned. The runtime block is
+ *     assembled from safe descriptors (persistence mode + adapter booleans).
+ *   - Read OR derivation failures fall back to a typed packet with warnings —
+ *     this route never throws.
+ */
+
+import { NextResponse } from "next/server";
+import { readWorkspaceConfig, readWorkspaceSourceRecords, describePersistenceMode } from "@/lib/workspace-config";
+import { readAdapterConfig } from "@/lib/adapters/env";
+import { deriveSwarmConditionPacket } from "@/lib/workspace-activation";
+
+const SWARM_PACKET_KIND = "growthub-swarm-condition-packet-v1";
+
+/** Assemble the safe runtime descriptor the lenses read (no secrets/values). */
+function safeRuntime(warnings) {
+  const runtime = { persistenceMode: "", persistenceAdapter: null, allowFsWrite: false, nangoConfigured: false, deploy: {} };
+  try {
+    const persistence = describePersistenceMode();
+    runtime.persistenceMode = persistence.mode;
+    runtime.allowFsWrite = persistence.mode === "filesystem" && persistence.canSave === true;
+    const adapter = readAdapterConfig();
+    runtime.persistenceAdapter = persistence.mode === "database" ? (adapter.dataAdapter || null) : null;
+    runtime.nangoConfigured = Boolean(adapter?.nango?.hasSecretKey);
+    runtime.deploy = { target: adapter.deployTarget || "" };
+  } catch (error) {
+    warnings.push(`Failed to read runtime descriptor: ${error?.message || "unknown error"}`);
+  }
+  return runtime;
+}
+
+async function GET(request) {
+  const warnings = [];
+
+  let lensId = "activation";
+  try {
+    const url = request && request.url ? new URL(request.url) : null;
+    const requested = url ? (url.searchParams.get("lensId") || "").trim() : "";
+    if (requested) lensId = requested;
+  } catch (error) {
+    warnings.push(`Failed to parse query: ${error?.message || "unknown error"}`);
+  }
+
+  let workspaceConfig = {};
+  try {
+    workspaceConfig = (await readWorkspaceConfig()) || {};
+  } catch (error) {
+    warnings.push(`Failed to read workspace config: ${error?.message || "unknown error"}`);
+  }
+
+  let workspaceSourceRecords = {};
+  try {
+    workspaceSourceRecords = (await readWorkspaceSourceRecords()) || {};
+  } catch (error) {
+    warnings.push(`Failed to read source records sidecar: ${error?.message || "unknown error"}`);
+  }
+
+  const metadataGraph = { runtime: safeRuntime(warnings) };
+
+  let packet;
+  try {
+    packet = deriveSwarmConditionPacket(
+      { workspaceConfig, workspaceSourceRecords, metadataGraph },
+      { lensId },
+    );
+  } catch (error) {
+    warnings.push(`Failed to derive swarm packet: ${error?.message || "unknown error"}`);
+    packet = {
+      kind: SWARM_PACKET_KIND,
+      version: 1,
+      lensId: "activation",
+      goal: "Activate this workspace.",
+      currentState: "0/0",
+      complete: false,
+      nextAction: null,
+      blockedStep: null,
+      prerequisite: null,
+      availableTools: [],
+      expectedEvidence: [],
+    };
+  }
+
+  return NextResponse.json({ ...packet, warnings });
+}
+
+export { GET };

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

@@ -0,0 +1,189 @@
+"use client";
+
+/**
+ * WorkspaceActivationPanel — customer activation checklist.
+ *
+ * Renders the derived activation state from
+ * `lib/workspace-activation.js` as a goal-first checklist with deep links
+ * into the existing surfaces. The panel is read-only; every step routes
+ * through routes the workspace already owns.
+ *
+ * Props:
+ *   workspaceConfig         — parsed growthub.config.json (governed)
+ *   workspaceSourceRecords  — parsed growthub.source-records.json (sidecar)
+ *   metadataGraph           — optional metadata graph envelope
+ *   onOpenHelper            — optional helper-thread CTA handler
+ *   compact                 — render the rail-friendly compact variant
+ *
+ * Invariants:
+ *   - No fetch. No mutation. No secret reading.
+ *   - Reads only safe data (booleans, status strings, deep-link routes).
+ *   - Falls back to a sensible default state if config is missing.
+ */
+
+import Link from "next/link";
+import {
+  ArrowRight,
+  Check,
+  CircleDot,
+  HelpCircle,
+  Lock,
+  Sparkles,
+} from "lucide-react";
+import { deriveWorkspaceActivationState } from "@/lib/workspace-activation";
+
+function StatusIcon({ status }) {
+  if (status === "complete") return <Check size={14} aria-hidden="true" />;
+  if (status === "blocked") return <Lock size={14} aria-hidden="true" />;
+  if (status === "optional") return <Sparkles size={14} aria-hidden="true" />;
+  return <CircleDot size={14} aria-hidden="true" />;
+}
+
+function StatusLabel({ status }) {
+  if (status === "complete") return "Done";
+  if (status === "blocked") return "Blocked";
+  if (status === "optional") return "Optional";
+  return "Next";
+}
+
+export function WorkspaceActivationPanel({
+  workspaceConfig,
+  workspaceSourceRecords,
+  metadataGraph,
+  onOpenHelper,
+  compact = false,
+  showLenses = false,
+}) {
+  const state = deriveWorkspaceActivationState({
+    workspaceConfig,
+    workspaceSourceRecords,
+    metadataGraph,
+  });
+
+  // Onboarding stays pure. Once the primary loop completes we don't render
+  // operating-state cards inside the checklist — we hand the user off to the
+  // dedicated Workspace Lens surface (the "you levelled up" moment).
+  const showLensTeaser = showLenses && !compact && state.complete;
+
+  const stepsToRender = compact
+    ? state.steps.filter((step) => step.status !== "optional")
+    : state.steps;
+
+  return (
+    <section
+      className={
+        "workspace-activation-panel"
+        + (compact ? " is-compact" : "")
+        + (state.complete ? " is-complete" : "")
+      }
+      aria-label="Workspace activation"
+      data-template={state.template}
+    >
+      <header className="workspace-activation-head">
+        <div className="workspace-activation-head-text">
+          <p className="workspace-activation-eyebrow">{state.templateName}</p>
+          <h2 className="workspace-activation-headline">{state.headline}</h2>
+          {state.subheadline ? (
+            <p className="workspace-activation-subheadline">{state.subheadline}</p>
+          ) : null}
+        </div>
+        <div
+          className="workspace-activation-progress"
+          aria-label={`${state.completedCount} of ${state.totalCount} setup steps complete`}
+        >
+          <span className="workspace-activation-progress-value">
+            {state.completedCount}/{state.totalCount}
+          </span>
+          <span className="workspace-activation-progress-bar" aria-hidden="true">
+            <span
+              className="workspace-activation-progress-fill"
+              style={{
+                width: state.totalCount > 0
+                  ? `${Math.min(100, Math.round((state.completedCount / state.totalCount) * 100))}%`
+                  : "0%",
+              }}
+            />
+          </span>
+        </div>
+      </header>
+
+      <ol className="workspace-activation-steps" role="list">
+        {stepsToRender.map((step) => {
+          const isNext = state.nextStepId === step.id;
+          return (
+            <li
+              key={step.id}
+              className={
+                "workspace-activation-step"
+                + ` is-${step.status}`
+                + (isNext ? " is-next" : "")
+              }
+            >
+              <span className="workspace-activation-step-status" aria-hidden="true">
+                <StatusIcon status={step.status} />
+              </span>
+              <div className="workspace-activation-step-body">
+                <div className="workspace-activation-step-titlebar">
+                  <h3 className="workspace-activation-step-title">{step.label}</h3>
+                  <span className={`workspace-activation-step-badge is-${step.status}`}>
+                    <StatusLabel status={step.status} />
+                  </span>
+                </div>
+                <p className="workspace-activation-step-description">{step.description}</p>
+                {step.hint ? (
+                  <p className="workspace-activation-step-hint">
+                    <HelpCircle size={12} aria-hidden="true" />
+                    <span>{step.hint}</span>
+                  </p>
+                ) : null}
+                {step.href ? (
+                  <Link
+                    href={step.href}
+                    className={
+                      "workspace-activation-step-cta"
+                      + (isNext ? " is-primary" : "")
+                    }
+                  >
+                    <span>{step.cta || (step.status === "complete" ? "Review" : "Open")}</span>
+                    <ArrowRight size={12} aria-hidden="true" />
+                  </Link>
+                ) : null}
+              </div>
+            </li>
+          );
+        })}
+      </ol>
+
+      {showLensTeaser ? (
+        <div className="workspace-activation-lens-teaser">
+          <span className="workspace-activation-lens-teaser-text">
+            Workspace Lens is now available — your live operating surface for state, blockers, and agent-assignable work.
+          </span>
+          <Link href="/workspace-lens" className="workspace-activation-lens-teaser-link">
+            Open Workspace Lens
+          </Link>
+        </div>
+      ) : null}
+
+      {onOpenHelper ? (
+        <div className="workspace-activation-helper-cta">
+          <button
+            type="button"
+            className="workspace-activation-helper-btn"
+            onClick={() => onOpenHelper({
+              template: state.template,
+              nextStepId: state.nextStepId,
+            })}
+          >
+            <Sparkles size={13} aria-hidden="true" />
+            <span>
+              {state.complete
+                ? "Ask helper to customize this workspace"
+                : `Ask helper to finish ${state.templateName}`}
+            </span>
+          </button>
+        </div>
+      ) : null}
+    </section>
+  );
+}

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

@@ -0,0 +1,119 @@
+"use client";
+
+/**
+ * WorkspaceContributionGraph — GitHub-style activity heatmap for the workspace.
+ *
+ * Renders the pure `deriveWorkspaceContributions` grid (53 weeks × 7 days) as a
+ * calm, developer-familiar contribution graph. The chrome is neutral; only the
+ * cells use the recognizable green intensity scale. On hover each day shows a
+ * minimal tooltip (count + date) with a link into the matching filtered lens
+ * view — so the graph becomes the entry point to a daily ritual: open the lens,
+ * read your activity, drill into the day, start work.
+ */
+
+import { useState } from "react";
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+function formatDay(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  return d.toLocaleDateString(undefined, { weekday: "short", month: "short", day: "numeric", year: "numeric", timeZone: "UTC" });
+}
+
+export function WorkspaceContributionGraph({ data, onSelectDay, buildDayHref }) {
+  const [hover, setHover] = useState(null);
+  if (!data || !Array.isArray(data.weeks) || data.weeks.length === 0) return null;
+
+  // Month labels: show a label above the first week whose first day starts a
+  // new month versus the previous column.
+  let prevMonth = -1;
+  const monthLabels = data.weeks.map((week) => {
+    const first = week.days[0];
+    const month = first ? new Date(first.date).getUTCMonth() : -1;
+    if (month !== prevMonth) { prevMonth = month; return MONTHS[month] || ""; }
+    return "";
+  });
+
+  return (
+    <section className="workspace-contrib" aria-label="Workspace contribution graph">
+      <div className="workspace-contrib-head">
+        <span className="workspace-contrib-total">{data.total} workspace contributions in the last year</span>
+        <span className="workspace-contrib-legend" aria-hidden="true">
+          Less
+          <i className="workspace-contrib-cell lvl-0" />
+          <i className="workspace-contrib-cell lvl-1" />
+          <i className="workspace-contrib-cell lvl-2" />
+          <i className="workspace-contrib-cell lvl-3" />
+          <i className="workspace-contrib-cell lvl-4" />
+          More
+        </span>
+      </div>
+
+      <div className="workspace-contrib-grid-wrap">
+        <div className="workspace-contrib-months" aria-hidden="true">
+          {monthLabels.map((label, i) => (
+            <span key={i} className="workspace-contrib-month">{label}</span>
+          ))}
+        </div>
+        <div className="workspace-contrib-body">
+          <div className="workspace-contrib-weekdays" aria-hidden="true">
+            <span />
+            <span>Mon</span>
+            <span />
+            <span>Wed</span>
+            <span />
+            <span>Fri</span>
+            <span />
+          </div>
+          <div className="workspace-contrib-weeks" role="img" aria-label={`${data.total} workspace contributions`}>
+            {data.weeks.map((week, wi) => (
+              <div key={wi} className="workspace-contrib-week">
+                {week.days.map((day) => (
+                  <button
+                    key={day.date}
+                    type="button"
+                    className={"workspace-contrib-cell lvl-" + (day.future ? "future" : day.level) + (day.count > 0 ? " has-count" : "")}
+                    disabled={day.future}
+                    data-count={day.count}
+                    aria-label={day.future ? "" : `${day.count} on ${formatDay(day.date)}`}
+                    onMouseEnter={(e) => {
+                      if (day.future) return;
+                      const r = e.currentTarget.getBoundingClientRect();
+                      setHover({ date: day.date, count: day.count, x: r.left + r.width / 2, y: r.top });
+                    }}
+                    onMouseLeave={() => setHover(null)}
+                    onClick={() => { if (!day.future && onSelectDay) onSelectDay(day.date); }}
+                  />
+                ))}
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {hover ? (
+        <div
+          className="workspace-contrib-tooltip"
+          style={{ left: hover.x, top: hover.y }}
+          role="tooltip"
+        >
+          <span className="workspace-contrib-tooltip-count">
+            {hover.count} contribution{hover.count === 1 ? "" : "s"}
+          </span>
+          <span className="workspace-contrib-tooltip-date">{formatDay(hover.date)}</span>
+          {hover.count > 0 && buildDayHref ? (
+            <a
+              className="workspace-contrib-tooltip-link"
+              href={buildDayHref(hover.date)}
+              target="_blank"
+              rel="noopener noreferrer"
+            >
+              Open day in Workspace Lens ↗
+            </a>
+          ) : null}
+        </div>
+      ) : null}
+    </section>
+  );
+}