@growthub/cli 0.9.18 → 0.10.1

package/dist/index.js

@@ -10255,6 +10255,7 @@ var init_growthub_bridge_client = __esm({
       constructor(session = readActiveSession()) {
         this.session = session;
       }
+      session;
       async listAssets(query = {}) {
         const url = bridgeUrl(this.session, "/api/cli/profile", {
           view: "gallery-assets",
@@ -11249,6 +11250,65 @@ var init_scaffold_session_memory = __esm({
 // src/starter/init.ts
 import fs58 from "node:fs";
 import path68 from "node:path";
+function readJsonFile2(filePath) {
+  return JSON.parse(fs58.readFileSync(filePath, "utf8"));
+}
+function mergeDataModelObjects(baseObjects, seedObjects) {
+  const readId = (value) => {
+    const candidate = value.id;
+    return typeof candidate === "string" ? candidate : "";
+  };
+  const merged = [...baseObjects];
+  const indexById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < merged.length; i += 1) {
+    const id = readId(merged[i]);
+    if (id) indexById.set(id, i);
+  }
+  for (const seedObject of seedObjects) {
+    const id = readId(seedObject);
+    if (id && indexById.has(id)) {
+      merged[indexById.get(id)] = {
+        ...merged[indexById.get(id)],
+        ...seedObject
+      };
+      continue;
+    }
+    merged.push(seedObject);
+    if (id) indexById.set(id, merged.length - 1);
+  }
+  return merged;
+}
+function applySeededConfig(opts) {
+  const seedSlug = opts.seedConfig.trim();
+  if (!seedSlug) return;
+  const seedPath = path68.join(opts.kitPath, "templates", "seeded-configs", `${seedSlug}.config.json`);
+  if (!fs58.existsSync(seedPath)) {
+    throw new Error(
+      `Seeded config "${seedSlug}" was not found at ${seedPath}. Create templates/seeded-configs/<slug>.config.json in the starter kit first.`
+    );
+  }
+  const outConfigPath = path68.join(opts.outPath, "apps", "workspace", "growthub.config.json");
+  if (!fs58.existsSync(outConfigPath)) {
+    throw new Error(`Expected workspace config at ${outConfigPath} while applying seeded config "${seedSlug}".`);
+  }
+  const baseConfig = readJsonFile2(outConfigPath);
+  const seedConfig = readJsonFile2(seedPath);
+  const mergedObjects = mergeDataModelObjects(
+    Array.isArray(baseConfig.dataModel?.objects) ? baseConfig.dataModel.objects : [],
+    Array.isArray(seedConfig.dataModel?.objects) ? seedConfig.dataModel.objects : []
+  );
+  const mergedConfig = {
+    ...baseConfig,
+    ...seedConfig,
+    dataModel: {
+      ...baseConfig.dataModel || {},
+      ...seedConfig.dataModel || {},
+      objects: mergedObjects
+    }
+  };
+  fs58.writeFileSync(outConfigPath, `${JSON.stringify(mergedConfig, null, 2)}
+`, "utf8");
+}
 async function initStarterWorkspace(opts) {
   const kitId = opts.kitId ?? DEFAULT_STARTER_KIT_ID;
   const absOut = path68.resolve(opts.out);
@@ -11257,6 +11317,13 @@ async function initStarterWorkspace(opts) {
   }
   const info = getBundledKitSourceInfo(kitId);
   copyBundledKitSource(kitId, absOut);
+  if (opts.seedConfig) {
+    applySeededConfig({
+      outPath: absOut,
+      kitPath: info.assetRoot,
+      seedConfig: opts.seedConfig
+    });
+  }
   const reg = registerKitFork({
     forkPath: absOut,
     kitId: info.id,
@@ -29569,6 +29636,329 @@ function cleanMarkdownResponse(text70) {
   return cleaned.trim();
 }
 
+// src/runtime/native-intelligence/tool-intent-policy.ts
+function contractForSlug(slug, contracts) {
+  return contracts.find((c) => c.slug === slug);
+}
+function validateIntentInputAgainstContract(intent, contract) {
+  const warnings = [];
+  const allowedKeys = new Set(contract.inputs.map((i) => i.key));
+  for (const key of Object.keys(intent.input)) {
+    if (!allowedKeys.has(key)) {
+      warnings.push(`stripped unknown field "${key}" on tool "${intent.toolSlug}"`);
+    }
+  }
+  for (const field of contract.inputs) {
+    if (!field.required) continue;
+    const v = intent.input[field.key];
+    if (v === void 0 || v === null || v === "") {
+      warnings.push(`missing required contract field "${field.key}" for tool "${intent.toolSlug}"`);
+    }
+  }
+  return warnings;
+}
+function validateLocalModelToolIntents(intents, policy, availableContracts) {
+  const validated = [];
+  const rejected = [];
+  const warnings = [];
+  if (policy.mode === "disabled") {
+    for (const intent of intents) {
+      rejected.push({
+        intent,
+        reasons: ["tool policy mode is disabled"]
+      });
+    }
+    return { validated, rejected, warnings };
+  }
+  const allowed = new Set(policy.allowedToolSlugs.map((s) => s.trim()).filter(Boolean));
+  const minConfidence = typeof policy.minConfidence === "number" ? policy.minConfidence : void 0;
+  for (const intent of intents) {
+    const reasons = [];
+    const slug = String(intent.toolSlug || "").trim();
+    if (!slug) {
+      reasons.push("missing toolSlug");
+      rejected.push({ intent, reasons });
+      continue;
+    }
+    if (!allowed.has(slug)) {
+      reasons.push(`toolSlug "${slug}" is not in allowedToolSlugs`);
+    }
+    const contract = contractForSlug(slug, availableContracts);
+    if (!contract) {
+      reasons.push(`no contract summary for slug "${slug}"`);
+    }
+    if (minConfidence !== void 0 && !(typeof intent.confidence === "number" && intent.confidence >= minConfidence)) {
+      reasons.push(`confidence ${intent.confidence} below minimum ${minConfidence}`);
+    }
+    if (reasons.length) {
+      rejected.push({ intent: { ...intent, toolSlug: slug }, reasons });
+      continue;
+    }
+    const contractNonNull = contract;
+    const fieldWarnings = validateIntentInputAgainstContract({ ...intent, toolSlug: slug }, contractNonNull);
+    warnings.push(...fieldWarnings);
+    const strippedInput = {};
+    const allowedKeys = new Set(contractNonNull.inputs.map((i) => i.key));
+    for (const [k, v] of Object.entries(intent.input)) {
+      if (allowedKeys.has(k)) strippedInput[k] = v;
+    }
+    validated.push({
+      ...intent,
+      toolSlug: slug,
+      input: strippedInput,
+      warnings: fieldWarnings
+    });
+  }
+  return { validated, rejected, warnings };
+}
+
+// src/runtime/native-intelligence/sandbox-runner.ts
+var ENVELOPE_VERSION = "growthub-local-model-sandbox-v1";
+function traceLine(type, payload) {
+  return JSON.stringify({ type, at: (/* @__PURE__ */ new Date()).toISOString(), ...payload });
+}
+function defaultToolPolicy(ctx) {
+  return ctx.toolPolicy ?? {
+    mode: "propose-only",
+    allowedToolSlugs: ctx.allowedToolSlugs,
+    requiresDeterministicValidation: true
+  };
+}
+function buildSandboxSystemPrompt(input) {
+  const ctx = input.context;
+  const policy = defaultToolPolicy(ctx);
+  const contractSummaries = ctx.availableContracts.map((c) => ({
+    slug: c.slug,
+    displayName: c.displayName,
+    requiredBindings: c.requiredBindings,
+    inputs: c.inputs.map((i) => ({ key: i.key, required: i.required, type: i.type }))
+  }));
+  const schemaHint = input.responseSchema ? `
+Optional response schema hint (follow when compatible):
+${JSON.stringify(input.responseSchema)}
+` : "";
+  return [
+    "You are Growthub Local Intelligence in a governed sandbox.",
+    "Return a single JSON object only (no markdown fences).",
+    "You must not claim to have executed tools or APIs.",
+    "toolIntents are proposals only; include confidence between 0 and 1.",
+    "",
+    `taskId: ${ctx.taskId}`,
+    `businessObjectType: ${input.businessObjectType}`,
+    input.businessObjectId ? `businessObjectId: ${input.businessObjectId}` : "",
+    `executionMode: ${ctx.executionMode}`,
+    `toolPolicy.mode: ${policy.mode}`,
+    `allowedToolSlugs: ${JSON.stringify(ctx.allowedToolSlugs)}`,
+    "",
+    "Available CMS / node contracts (summaries):",
+    JSON.stringify(contractSummaries, null, 2),
+    "",
+    ctx.bindings ? `Current bindings:
+${JSON.stringify(ctx.bindings)}
+` : "",
+    ctx.sourceRecordRefs?.length ? `sourceRecordRefs: ${JSON.stringify(ctx.sourceRecordRefs)}
+` : "",
+    schemaHint,
+    "JSON shape:",
+    "{",
+    '  "text": string (optional concise narrative),',
+    '  "json": object (optional structured payload),',
+    '  "toolIntents": [{ "toolSlug", "reason", "input", "confidence" }],',
+    '  "warnings": string[],',
+    '  "confidence": number',
+    "}"
+  ].filter(Boolean).join("\n");
+}
+function buildSandboxUserPrompt(input) {
+  return [`User intent:
+${input.userIntent.trim()}`].join("\n\n");
+}
+function buildLocalIntelligenceSandboxPrompts(input) {
+  return {
+    systemPrompt: buildSandboxSystemPrompt(input),
+    userPrompt: buildSandboxUserPrompt(input)
+  };
+}
+function coerceToolIntents(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const rec = item;
+    const toolSlug = typeof rec.toolSlug === "string" ? rec.toolSlug.trim() : "";
+    if (!toolSlug) continue;
+    const reason = typeof rec.reason === "string" ? rec.reason : "";
+    const inputObj = rec.input && typeof rec.input === "object" && !Array.isArray(rec.input) ? rec.input : {};
+    const confidence = typeof rec.confidence === "number" && Number.isFinite(rec.confidence) ? rec.confidence : 0;
+    out.push({ toolSlug, reason, input: inputObj, confidence });
+  }
+  return out;
+}
+function parseLocalModelSandboxResult(rawText) {
+  const warnings = [];
+  const trimmed = rawText.trim();
+  if (!trimmed) {
+    return { toolIntents: [], warnings: ["empty model response"], confidence: 0 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return {
+      text: trimmed,
+      toolIntents: [],
+      warnings: ["model output was not valid JSON"],
+      confidence: 0
+    };
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { toolIntents: [], warnings: ["parsed JSON was not an object"], confidence: 0 };
+  }
+  const obj = parsed;
+  const text70 = typeof obj.text === "string" ? obj.text : void 0;
+  const json = obj.json && typeof obj.json === "object" && !Array.isArray(obj.json) ? obj.json : void 0;
+  const toolIntents = coerceToolIntents(obj.toolIntents);
+  const w = Array.isArray(obj.warnings) ? obj.warnings.filter((w2) => typeof w2 === "string") : [];
+  warnings.push(...w);
+  const confidence = typeof obj.confidence === "number" && Number.isFinite(obj.confidence) ? obj.confidence : 0;
+  return { text: text70, json, toolIntents, warnings, confidence };
+}
+function emptyEnvelope(input, config, adapterMode, message, fallback) {
+  const result = {
+    toolIntents: [],
+    warnings: [message],
+    confidence: 0
+  };
+  return {
+    version: ENVELOPE_VERSION,
+    taskId: input.taskId,
+    businessObjectType: input.businessObjectType,
+    businessObjectId: input.businessObjectId,
+    adapter: {
+      kind: "local-intelligence",
+      mode: adapterMode,
+      modelId: config.localModel ?? config.modelId,
+      endpoint: config.endpoint
+    },
+    result,
+    validatedToolIntents: [],
+    rejectedToolIntents: [],
+    rawText: "",
+    latencyMs: 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    trace: [traceLine("local-model-sandbox-run-completed", { taskId: input.taskId, ok: false, fallback })],
+    fallback
+  };
+}
+async function runLocalIntelligenceSandboxTask(input, config, options) {
+  const adapterMode = String(input.adapterMode ?? "ollama");
+  const toolPolicy = defaultToolPolicy(input.context);
+  const trace = [];
+  trace.push(traceLine("local-intelligence-adapter-selected", { kind: "local-intelligence", mode: adapterMode }));
+  trace.push(traceLine("local-model-sandbox-run-started", { taskId: input.taskId }));
+  const systemPrompt = buildSandboxSystemPrompt(input);
+  const userPrompt = buildSandboxUserPrompt(input);
+  const backend = options?.backend ?? createNativeIntelligenceBackend(config);
+  let rawText = "";
+  let latencyMs = 0;
+  let resolvedModelId = config.localModel ?? config.modelId;
+  try {
+    const completion = await backend.complete({
+      systemPrompt,
+      userPrompt,
+      temperature: config.defaultTemperature,
+      maxTokens: config.defaultMaxTokens,
+      responseFormat: "json",
+      sandboxContext: input.context,
+      toolPolicy
+    });
+    rawText = completion.text;
+    latencyMs = completion.latencyMs;
+    resolvedModelId = completion.modelId || resolvedModelId;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "model backend error";
+    trace.push(traceLine("local-model-sandbox-run-completed", { taskId: input.taskId, ok: false, error: message }));
+    const env = emptyEnvelope(input, config, adapterMode, message, true);
+    env.trace = [...trace, ...env.trace ?? []];
+    return env;
+  }
+  const parsed = parseLocalModelSandboxResult(rawText);
+  for (const intent of parsed.toolIntents) {
+    trace.push(traceLine("local-model-tool-intent-proposed", { toolSlug: intent.toolSlug, confidence: intent.confidence }));
+  }
+  const validation = validateLocalModelToolIntents(parsed.toolIntents, toolPolicy, input.context.availableContracts);
+  for (const r of validation.rejected) {
+    trace.push(traceLine("local-model-tool-intent-rejected", { toolSlug: r.intent.toolSlug, reasons: r.reasons }));
+  }
+  const mergedWarnings = [...parsed.warnings, ...validation.warnings];
+  const result = {
+    text: parsed.text,
+    json: parsed.json,
+    toolIntents: parsed.toolIntents,
+    warnings: mergedWarnings,
+    confidence: parsed.confidence
+  };
+  trace.push(traceLine("local-model-sandbox-run-completed", { taskId: input.taskId, ok: true }));
+  return {
+    version: ENVELOPE_VERSION,
+    taskId: input.taskId,
+    businessObjectType: input.businessObjectType,
+    businessObjectId: input.businessObjectId,
+    adapter: {
+      kind: "local-intelligence",
+      mode: adapterMode,
+      modelId: resolvedModelId,
+      endpoint: config.endpoint
+    },
+    result,
+    validatedToolIntents: validation.validated,
+    rejectedToolIntents: validation.rejected,
+    rawText,
+    latencyMs,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    trace,
+    fallback: false
+  };
+}
+
+// src/runtime/native-intelligence/source-record-export.ts
+import { createHash as createHash3 } from "node:crypto";
+function hashSystemPrompt(systemPrompt) {
+  return createHash3("sha256").update(systemPrompt, "utf8").digest("hex");
+}
+function sandboxEnvelopeToTraceRecord(envelope, options) {
+  return {
+    version: "growthub-local-intelligence-trace-v1",
+    taskId: envelope.taskId,
+    businessObjectType: envelope.businessObjectType,
+    businessObjectId: envelope.businessObjectId,
+    modelId: envelope.adapter.modelId,
+    systemPromptHash: hashSystemPrompt(options.systemPrompt),
+    input: {
+      userIntent: options.userIntent,
+      availableContracts: options.availableContracts ?? [],
+      bindings: envelope.result.json && typeof envelope.result.json === "object" && envelope.result.json !== null && "bindings" in envelope.result.json && typeof envelope.result.json.bindings === "object" ? envelope.result.json.bindings : void 0
+    },
+    output: {
+      json: envelope.result.json,
+      toolIntents: envelope.result.toolIntents,
+      warnings: [
+        ...envelope.result.warnings,
+        ...envelope.validatedToolIntents?.flatMap((v) => v.warnings) ?? []
+      ]
+    },
+    validation: {
+      acceptedToolIntents: envelope.validatedToolIntents ?? [],
+      rejectedToolIntents: envelope.rejectedToolIntents ?? []
+    },
+    createdAt: envelope.createdAt
+  };
+}
+function formatTraceRecordLine(record) {
+  return `${JSON.stringify(record)}
+`;
+}
+
 // src/runtime/native-intelligence/index.ts
 function resolveConfigPath2() {
   return path50.resolve(resolvePaperclipHomeDir(), "native-intelligence", "config.json");
@@ -35599,10 +35989,11 @@ async function runBrowseSkills(opts) {
 }
 function registerStarterCommands(program2) {
   const starter = program2.command("starter").description("Custom Workspace Starter Kit \u2014 scaffold or import a fork with full v1 Self-Healing Fork Sync wiring.");
-  starter.command("init").description("Scaffold a new custom workspace from the starter kit and auto-register it as a fork.").requiredOption("--out <path>", "Destination directory for the new workspace").option("--kit <kit-id>", `Source kit id (default: ${DEFAULT_STARTER_KIT_ID})`).option("--name <label>", "Human label for the fork").option("--upstream <owner/repo>", "Upstream GitHub repo \u2014 when set, also creates a remote fork").option("--destination-org <org>", "Create the GitHub fork under an org").option("--fork-name <name>", "Override the GitHub fork name").option("--remote-sync-mode <mode>", "Initial policy.remoteSyncMode \u2014 off|branch|pr (default: off)").option("--json", "Emit machine-readable output").action(async (opts) => {
+  starter.command("init").description("Scaffold a new custom workspace from the starter kit and auto-register it as a fork.").requiredOption("--out <path>", "Destination directory for the new workspace").option("--kit <kit-id>", `Source kit id (default: ${DEFAULT_STARTER_KIT_ID})`).option("--seed-config <slug>", "Named seeded config from templates/seeded-configs/<slug>.config.json").option("--name <label>", "Human label for the fork").option("--upstream <owner/repo>", "Upstream GitHub repo \u2014 when set, also creates a remote fork").option("--destination-org <org>", "Create the GitHub fork under an org").option("--fork-name <name>", "Override the GitHub fork name").option("--remote-sync-mode <mode>", "Initial policy.remoteSyncMode \u2014 off|branch|pr (default: off)").option("--json", "Emit machine-readable output").action(async (opts) => {
     await runStarterInit({
       out: opts.out,
       kitId: opts.kit ?? DEFAULT_STARTER_KIT_ID,
+      seedConfig: opts.seedConfig,
       name: opts.name,
       upstream: opts.upstream,
       destinationOrg: opts.destinationOrg,
@@ -39681,6 +40072,7 @@ async function runNativeIntelligenceHub() {
         { value: "models", label: "Manage local custom models", hint: "select active favorite/default model" },
         { value: "prompt", label: "Prompt local model (chat flow)", hint: "human first local prompt submissions" },
         { value: "flows", label: "Run native-intelligence with your prompt", hint: "planner/normalizer/recommender/summarizer" },
+        { value: "sandbox", label: "Run sandboxed local model task", hint: "governed JSON + validated tool intents (no execution)" },
         { value: "marketing-context", label: "Marketing Context Builder", hint: "auto-draft product-marketing-context from project artifacts" },
         { value: "provider-config", label: "Configure API provider", hint: "Claude, OpenAI, Gemini, OpenRouter, or local" },
         { value: "__back_to_hub", label: "\u2190 Back to main menu" }
@@ -39794,6 +40186,10 @@ API key: ${result.apiKey ? "configured" : "not needed"}`,
       await runMarketingContextBuilder(baseUrl, defaultModel);
       continue;
     }
+    if (action === "sandbox") {
+      await runLocalIntelligenceSandboxDiscovery(baseUrl, defaultModel);
+      continue;
+    }
     const customPrompt = await p42.text({
       message: "Enter your local intelligence prompt",
       placeholder: "Describe what you want to create/analyze"
@@ -39807,6 +40203,95 @@ API key: ${result.apiKey ? "configured" : "not needed"}`,
     await runNativeIntelligenceFlowSuite(baseUrl, defaultModel, prompt);
   }
 }
+async function runLocalIntelligenceSandboxDiscovery(baseUrl, defaultModel) {
+  const userIntent = await p42.text({
+    message: "Describe the governed sandbox task",
+    placeholder: "e.g. Inspect bindings and propose safe next steps"
+  });
+  if (p42.isCancel(userIntent)) return;
+  const intent = String(userIntent).trim();
+  if (!intent) {
+    p42.note("Intent was empty.", "Sandboxed local model");
+    return;
+  }
+  const boRaw = await p42.text({
+    message: "Business object type (metadata label)",
+    placeholder: "sandbox-environment",
+    defaultValue: "sandbox-environment"
+  });
+  if (p42.isCancel(boRaw)) return;
+  const businessObjectType = String(boRaw || "sandbox-environment").trim() || "sandbox-environment";
+  const spinner15 = p42.spinner();
+  spinner15.start("Loading contracts and running governed local model sandbox\u2026");
+  try {
+    const contracts = await loadRuntimeContracts();
+    const allowed = contracts.map((c) => c.slug);
+    const config = {
+      ...readIntelligenceConfig(),
+      backendType: "local",
+      endpoint: `${baseUrl.replace(/\/$/, "")}/chat/completions`,
+      localModel: defaultModel
+    };
+    const health = await checkBackendHealth(config);
+    const taskId = `task_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    const taskInput = {
+      taskId,
+      businessObjectType,
+      userIntent: intent,
+      context: {
+        taskId,
+        businessObjectType,
+        executionMode: "local",
+        allowedToolSlugs: allowed,
+        availableContracts: contracts,
+        toolPolicy: {
+          mode: "propose-only",
+          allowedToolSlugs: allowed,
+          requiresDeterministicValidation: true,
+          minConfidence: 0.15
+        }
+      },
+      adapterMode: "ollama"
+    };
+    const envelope = await runLocalIntelligenceSandboxTask(taskInput, config);
+    spinner15.stop(health.available ? "Sandbox run finished." : "Sandbox run finished (check backend health).");
+    const tracePreview = (envelope.trace ?? []).slice(-8).join("\n");
+    p42.note(
+      [
+        `adapter: ${envelope.adapter.mode} \xB7 model: ${envelope.adapter.modelId}`,
+        `latencyMs: ${envelope.latencyMs}`,
+        `confidence: ${envelope.result.confidence}`,
+        `validated intents: ${envelope.validatedToolIntents?.length ?? 0} \xB7 rejected: ${envelope.rejectedToolIntents?.length ?? 0}`,
+        envelope.fallback ? "Note: deterministic fallback envelope after backend error." : "",
+        "",
+        "Trace (recent):",
+        tracePreview || "(none)",
+        "",
+        "Envelope JSON:",
+        JSON.stringify(envelope, null, 2).slice(0, 12e3)
+      ].filter(Boolean).join("\n"),
+      "Governed local model sandbox"
+    );
+    const exportChoice = await p42.confirm({
+      message: "Print one JSONL distillation trace line to copy?",
+      initialValue: false
+    });
+    if (!p42.isCancel(exportChoice) && exportChoice) {
+      const prompts = buildLocalIntelligenceSandboxPrompts(taskInput);
+      const line = formatTraceRecordLine(
+        sandboxEnvelopeToTraceRecord(envelope, {
+          systemPrompt: prompts.systemPrompt,
+          userIntent: intent,
+          availableContracts: contracts.map((c) => ({ slug: c.slug, displayName: c.displayName }))
+        })
+      );
+      p42.note(line.trimEnd(), "JSONL trace record");
+    }
+  } catch (err) {
+    spinner15.stop("Sandbox run failed.");
+    p42.note(err instanceof Error ? err.message : String(err), "Governed local model sandbox");
+  }
+}
 async function runMarketingContextBuilder(baseUrl, model) {
   const projectDir = await p42.text({
     message: "Project directory to scan",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growthub/cli",
-  "version": "0.9.18",
+  "version": "0.10.1",
   "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": {