@growthub/cli 0.13.7 → 0.13.9

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

@@ -0,0 +1,13 @@
+import { NextResponse } from "next/server";
+import { listLocalCodexSites } from "@/lib/codex-sites-local-state";
+
+async function GET() {
+  const sites = await listLocalCodexSites();
+  return NextResponse.json({
+    ok: true,
+    source: "codex-local-session-state",
+    sites
+  });
+}
+
+export { GET };

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/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

@@ -52,6 +52,7 @@ export function WorkspaceActivationPanel({
   metadataGraph,
   onOpenHelper,
   compact = false,
+  showLenses = false,
 }) {
   const state = deriveWorkspaceActivationState({
     workspaceConfig,
@@ -59,6 +60,11 @@ export function WorkspaceActivationPanel({
     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;
@@ -148,6 +154,17 @@ export function WorkspaceActivationPanel({
         })}
       </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

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>
+  );
+}