@growthub/cli 0.13.9 → 0.14.1

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/workflows/WorkflowSurface.jsx

@@ -4,9 +4,10 @@ import { useCallback, useEffect, useMemo, useState } from "react";
 import Link from "next/link";
 import { useRouter, useSearchParams } from "next/navigation";
 import {
+  ArrowDown,
+  ArrowUp,
+  ArrowUpCircle,
   Bot,
-  ChevronDown,
-  ChevronUp,
   Code,
   Filter,
   FormInput,
@@ -51,7 +52,31 @@ import { AgentSwarmPanel } from "../data-model/components/AgentSwarmPanel.jsx";
 import { RunSetupPanel } from "./RunSetupPanel.jsx";
 import { describeRunInputMetadataItems, discoverRunInputSchema } from "@/lib/orchestration-run-inputs";
 import { selectWorkflowNodeInputSchema } from "@/lib/workspace-metadata-selectors";
-import { deriveProvenance, hasConnectionId } from "@/lib/workspace-activation";
+import { deriveProvenance, hasConnectionId, readUiCacheFlag } from "@/lib/workspace-activation";
+import { ApiRegistryCreationCockpit } from "../data-model/components/ApiRegistryCreationCockpit.jsx";
+import { deriveSandboxServerlessState } from "@/lib/sandbox-serverless-flow";
+import { deriveServerlessUpgradeState, SERVERLESS_UPGRADE_DISMISS_FLAG } from "@/lib/serverless-upgrade";
+
+// Set a flag on the governed workspace-ui-cache "activation" row (pure helper,
+// same transform the rail/lens one-time dismisses use).
+function withUiCacheFlag(workspaceConfig, flag, value) {
+  const dm = workspaceConfig?.dataModel && typeof workspaceConfig.dataModel === "object" ? workspaceConfig.dataModel : {};
+  const objects = Array.isArray(dm.objects) ? dm.objects : [];
+  const existing = objects.find((o) => o?.id === "workspace-ui-cache");
+  const baseRow = (existing?.rows || []).find((r) => r?.id === "activation") || { id: "activation" };
+  const nextRow = { ...baseRow, [flag]: value };
+  const nextCache = existing
+    ? { ...existing, rows: [nextRow, ...(existing.rows || []).filter((r) => r?.id !== "activation")] }
+    : {
+        id: "workspace-ui-cache", label: "Workspace UI Cache", source: "Workspace UI Cache",
+        objectType: "custom", columns: ["id", flag], rows: [nextRow],
+        binding: { mode: "manual", source: "Workspace UI Cache" },
+      };
+  const nextObjects = existing
+    ? objects.map((o) => (o?.id === "workspace-ui-cache" ? nextCache : o))
+    : [...objects, nextCache];
+  return { ...workspaceConfig, dataModel: { ...dm, objects: nextObjects } };
+}
 
 // Workspace Metadata Graph V1 — read-only dependency metadata for workflow
 // sidecars. The runtime path (sandbox-run, publish, draft/live) is
@@ -63,20 +88,33 @@ const WORKFLOW_METADATA_SELECTORS = Object.freeze({
 });
 
 function resolveRegistryRowForSandbox(workspaceConfig, sandboxRow) {
+  return resolveRegistryRefForSandbox(workspaceConfig, sandboxRow)?.row || null;
+}
+
+function resolveRegistryRefForSandbox(workspaceConfig, sandboxRow) {
   const graph = parseOrchestrationGraph(sandboxRow?.orchestrationConfig || sandboxRow?.orchestrationGraph);
   const apiNode = graph?.nodes?.find((n) => n?.type === "api-registry-call");
   const registryId = String(
     apiNode?.config?.registryId || apiNode?.config?.integrationId || sandboxRow?.schedulerRegistryId || ""
   ).trim();
-  if (!registryId || !workspaceConfig) return null;
+  if (!workspaceConfig) return null;
   const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  let firstRegistryRow = null;
+  let firstRegistryObject = null;
   for (const objectItem of objects) {
     if (objectItem?.objectType !== "api-registry") continue;
     const rows = Array.isArray(objectItem.rows) ? objectItem.rows : [];
-    const match = rows.find((r) => String(r?.integrationId || "").trim() === registryId);
-    if (match) return match;
+    const firstRow = rows.find((r) => String(r?.integrationId || "").trim());
+    if (!firstRegistryRow && firstRow) {
+      firstRegistryRow = firstRow;
+      firstRegistryObject = objectItem;
+    }
+    if (registryId) {
+      const match = rows.find((r) => String(r?.integrationId || "").trim() === registryId);
+      if (match) return { object: objectItem, row: match };
+    }
   }
-  return null;
+  return firstRegistryRow ? { object: firstRegistryObject, row: firstRegistryRow } : null;
 }
 
 function patchSandboxRowInConfig(workspaceConfig, objectId, rowIndex, fields) {
@@ -97,6 +135,29 @@ function patchSandboxRowInConfig(workspaceConfig, objectId, rowIndex, fields) {
   };
 }
 
+function nodeSandboxRecordRef(objectId, rowName, nodeId) {
+  return {
+    objectId: String(objectId || "").trim(),
+    rowName: String(rowName || "").trim(),
+    nodeId: String(nodeId || "").trim()
+  };
+}
+
+function withGraphSandboxRecordRefs(graph, objectId, rowName) {
+  const parsed = parseOrchestrationGraph(graph) || graph;
+  if (!parsed || typeof parsed !== "object") return parsed;
+  return {
+    ...parsed,
+    nodes: (Array.isArray(parsed.nodes) ? parsed.nodes : []).map((node) => ({
+      ...node,
+      config: {
+        ...(node?.config || {}),
+        sandboxRecordRef: nodeSandboxRecordRef(objectId, rowName, node?.id)
+      }
+    }))
+  };
+}
+
 const WORKFLOW_ACTION_GROUPS = [
   {
     label: "Data",
@@ -205,6 +266,7 @@ function getNodeDeltaRecords(previousGraph, nextGraph) {
         nodeId,
         nodeType: String(node?.type || ""),
         label: String(node?.label || node?.sandbox || nodeId),
+        sandboxRecordRef: config.sandboxRecordRef || null,
         changeReason,
         deltaTags,
         requiresRetest: config.requiresRetest !== false,
@@ -349,6 +411,23 @@ export default function WorkflowSurface() {
   const [orchestrationGraph, setOrchestrationGraph] = useState(null);
   const [dirty, setDirty] = useState(false);
   const [runSetupOpen, setRunSetupOpen] = useState(false);
+  const [upgradeOpen, setUpgradeOpen] = useState(false);
+  const [serverlessSignals, setServerlessSignals] = useState({ configuredEnvRefs: [], persistenceAdapters: [] });
+
+  useEffect(() => {
+    let cancelled = false;
+    fetch("/api/workspace/env-status", { cache: "no-store" })
+      .then((res) => (res.ok ? res.json() : {}))
+      .then((payload) => {
+        if (cancelled) return;
+        setServerlessSignals({
+          configuredEnvRefs: Array.isArray(payload.configuredEnvRefs) ? payload.configuredEnvRefs : [],
+          persistenceAdapters: Array.isArray(payload.persistenceAdapters) ? payload.persistenceAdapters : [],
+        });
+      })
+      .catch(() => {});
+    return () => { cancelled = true; };
+  }, [objectId, rowId]);
 
   const load = useCallback(async () => {
     setLoading(true);
@@ -442,8 +521,16 @@ export default function WorkflowSurface() {
 
   const selectedNode = useMemo(() => {
     if (!orchestrationGraph?.nodes || !selectedNodeId) return null;
-    return orchestrationGraph.nodes.find((n) => String(n.id) === selectedNodeId) || null;
-  }, [orchestrationGraph, selectedNodeId]);
+    const node = orchestrationGraph.nodes.find((n) => String(n.id) === selectedNodeId) || null;
+    if (!node) return null;
+    return {
+      ...node,
+      config: {
+        ...(node.config || {}),
+        sandboxRecordRef: nodeSandboxRecordRef(objectId, rowId, node.id)
+      }
+    };
+  }, [orchestrationGraph, selectedNodeId, objectId, rowId]);
 
   useEffect(() => {
     if (graphUnset || graphBlankShell) {
@@ -466,7 +553,7 @@ export default function WorkflowSurface() {
   }
 
   function serializeCurrentGraph() {
-    return graphUnset ? "" : serializeOrchestrationGraph(orchestrationGraph);
+    return graphUnset ? "" : serializeOrchestrationGraph(withGraphSandboxRecordRefs(orchestrationGraph, objectId, rowId));
   }
 
   async function saveDraft(extraFields = {}) {
@@ -533,7 +620,8 @@ export default function WorkflowSurface() {
       const nextVersion = Number.isFinite(currentVersion) ? String(currentVersion + 1) : "1";
       const previousDeltas = Array.isArray(sandboxRow?.orchestrationDeltas) ? sandboxRow.orchestrationDeltas : [];
       const previousPublishedGraph = parseOrchestrationGraph(sandboxRow?.[effectiveFieldName]);
-      const nodeDeltas = getNodeDeltaRecords(previousPublishedGraph, orchestrationGraph);
+      const graphWithRefs = withGraphSandboxRecordRefs(orchestrationGraph, objectId, rowId);
+      const nodeDeltas = getNodeDeltaRecords(previousPublishedGraph, graphWithRefs);
       const deltaTags = normalizeDeltaTags(nodeDeltas.flatMap((delta) => delta.deltaTags));
       const changeReason = nodeDeltas.map((delta) => delta.changeReason).filter(Boolean).join("\n");
       const next = patchSandboxRowInConfig(workspaceConfig, objectId, resolved.rowIndex, {
@@ -743,8 +831,12 @@ export default function WorkflowSurface() {
   function handleNodeConfigChange(configPatch) {
     if (!selectedNodeId) return;
     const { __nodePatch, ...configOnly } = configPatch || {};
+    const recordRef = nodeSandboxRecordRef(objectId, rowId, selectedNodeId);
     setOrchestrationGraph((g) => {
-      const updated = updateGraphNode(g, selectedNodeId, configOnly);
+      const updated = updateGraphNode(g, selectedNodeId, {
+        ...configOnly,
+        sandboxRecordRef: recordRef
+      });
       if (!__nodePatch || typeof __nodePatch !== "object") return updated;
       const parsed = parseOrchestrationGraph(updated) || updated;
       return {
@@ -807,6 +899,73 @@ export default function WorkflowSurface() {
   const showSaveDraft = dirty && !graphUnset;
   const workflowModeLabel = isDraftMode ? "draft" : lifecycle || "live";
 
+  // Serverless upgrade — same derivation + cockpit as the sandbox/API lanes.
+  const upgradeState = deriveServerlessUpgradeState(workspaceConfig || {}, {
+    dismissed: readUiCacheFlag(workspaceConfig || {}, SERVERLESS_UPGRADE_DISMISS_FLAG),
+  });
+  const serverlessState = sandboxRow
+    ? deriveSandboxServerlessState({
+        sandboxRow,
+        workspaceConfig: workspaceConfig || {},
+        configuredEnvRefs: serverlessSignals.configuredEnvRefs,
+        persistenceAdapters: serverlessSignals.persistenceAdapters,
+      })
+    : null;
+  const isServerlessWorkflow = Boolean(serverlessState?.isServerless);
+
+  async function patchSandboxAndPersist(fields) {
+    if (resolved.rowIndex < 0 || !objectId || !workspaceConfig) return;
+    try {
+      const next = patchSandboxRowInConfig(workspaceConfig, objectId, resolved.rowIndex, fields);
+      await persistWorkspace(next);
+      setSaveMessage(fields.runLocality === "serverless"
+        ? "Upgraded to serverless. Link a scheduler and configure persistence to close the loop."
+        : fields.runLocality === "local"
+          ? "Reverted to local execution."
+          : "Saved.");
+    } catch (err) {
+      setSaveMessage(err.message || "Failed to save");
+    }
+  }
+
+  async function handleUpgradeAction(action) {
+    if (!action) return;
+    if (action.id === "toggle-locality") {
+      if (isServerlessWorkflow) {
+        await patchSandboxAndPersist({ runLocality: "local" });
+        return;
+      }
+      const registryRow = resolveRegistryRowForSandbox(workspaceConfig, sandboxRow);
+      const adapterId = String(sandboxRow?.adapter || "").trim();
+      await patchSandboxAndPersist({
+        runLocality: "serverless",
+        schedulerRegistryId: String(registryRow?.integrationId || "").trim(),
+        adapter: ["local-agent-host", "local-intelligence"].includes(adapterId) ? "local-process" : adapterId,
+      });
+    } else if (action.id === "open-settings") {
+      router.push(action.href || "/settings");
+    } else if (action.id === "link-scheduler") {
+      const registryRef = resolveRegistryRefForSandbox(workspaceConfig, sandboxRow);
+      if (registryRef?.object?.id && registryRef?.row?.integrationId) {
+        router.push(`/data-model?object=${encodeURIComponent(registryRef.object.id)}&row=${encodeURIComponent(registryRef.row.integrationId)}`);
+      } else {
+        router.push(`/data-model?object=${encodeURIComponent(objectId)}&row=${encodeURIComponent(rowId)}`);
+      }
+    } else if (action.id === "edit-adapter") {
+      // Full scheduler/adapter config lives on the sandbox object's drawer.
+      router.push(`/data-model?object=${encodeURIComponent(objectId)}&row=${encodeURIComponent(rowId)}`);
+    }
+  }
+
+  async function dismissUpgradeOnboarding() {
+    if (!workspaceConfig) return;
+    try {
+      await persistWorkspace(withUiCacheFlag(workspaceConfig, SERVERLESS_UPGRADE_DISMISS_FLAG, true));
+    } catch {
+      /* non-fatal */
+    }
+  }
+
   return (
     <main className="workspace-builder dm-workflow-page">
       <WorkspaceRail
@@ -838,7 +997,7 @@ export default function WorkflowSurface() {
                 setAddTarget(null);
               }}
             >
-              <ChevronDown size={14} />
+              <ArrowDown size={13} />
             </button>
             <button
               type="button"
@@ -852,8 +1011,20 @@ export default function WorkflowSurface() {
                 setAddTarget(null);
               }}
             >
-              <ChevronUp size={14} />
+              <ArrowUp size={13} />
             </button>
+            {sandboxRow && (
+              <button
+                type="button"
+                className={"dm-workflow-icon-btn dm-workflow-upgrade-btn" + (isServerlessWorkflow ? " is-serverless" : (upgradeState.showOnboarding ? " is-pulse" : ""))}
+                aria-label={isServerlessWorkflow ? "Serverless workflow — review persistence & scheduling" : "Upgrade to serverless environment to ensure persistence"}
+                data-tooltip={isServerlessWorkflow ? "Serverless — review persistence & scheduling" : "Upgrade to serverless environment to ensure persistence"}
+                aria-pressed={upgradeOpen}
+                onClick={() => setUpgradeOpen((open) => !open)}
+              >
+                <ArrowUpCircle size={14} />
+              </button>
+            )}
             {showDiscardDraft && (
               <button
                 type="button"
@@ -920,6 +1091,43 @@ export default function WorkflowSurface() {
           </div>
         ) : null}
 
+        {/* One-time serverless upgrade onboarding — shows only when the operator
+            has workflows but none are serverless, and hasn't dismissed it. */}
+        {sandboxRow && !upgradeOpen && upgradeState.showOnboarding ? (
+          <div className="workspace-template-context-banner dm-workflow-upgrade-nudge" role="note">
+            <div>
+              <strong>{upgradeState.headline}</strong>
+              <span style={{ display: "block", marginTop: 2 }}>{upgradeState.subheadline}</span>
+            </div>
+            <div className="dm-workflow-upgrade-nudge-actions">
+              <button type="button" className="dm-btn-primary-sm" onClick={() => setUpgradeOpen(true)}>
+                <ArrowUpCircle size={13} /> Upgrade this workflow
+              </button>
+              <button type="button" className="dm-btn-ghost" onClick={dismissUpgradeOnboarding}>Not now</button>
+            </div>
+          </div>
+        ) : null}
+
+        {/* Serverless cockpit — same derivation + cockpit interface as the API
+            Registry and sandbox lanes. Toggles patch the sandbox row; deep config
+            (scheduler/adapter) routes to the object's Data Model drawer. */}
+        {sandboxRow && upgradeOpen && serverlessState ? (
+          <div className="dm-workflow-upgrade-panel">
+            <div className="dm-workflow-upgrade-panel-head">
+              <span className="dm-api-action-card-eyebrow">Persistence &amp; scheduling</span>
+              <button type="button" className="dm-workflow-icon-btn" aria-label="Close upgrade panel" onClick={() => { setUpgradeOpen(false); dismissUpgradeOnboarding(); }}>
+                <X size={14} />
+              </button>
+            </div>
+            <ApiRegistryCreationCockpit
+              state={serverlessState}
+              onAction={handleUpgradeAction}
+              disabled={saving || publishing || running}
+              eyebrow={isServerlessWorkflow ? "Serverless workflow" : "Upgrade to serverless"}
+            />
+          </div>
+        ) : null}
+
         {loading ? (
           <p className="dm-workflow-empty">Loading workflow…</p>
         ) : error ? (
@@ -1023,6 +1231,8 @@ export default function WorkflowSurface() {
                   </div>
                   <AgentSwarmPanel
                     graph={orchestrationGraph}
+                    objectId={objectId}
+                    rowName={rowId}
                     disabled={false}
                     onGraphChange={(updater) => {
                       setOrchestrationGraph((g) => (typeof updater === "function" ? updater(g) : updater));

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/integrations/resolver-loader.js

@@ -28,11 +28,9 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 
 const staticLoaded = new Set();
-let staticLoadDone = false;
+const nativeImport = new Function("specifier", "return import(specifier)");
 
 async function loadStaticResolversOnce() {
-  if (staticLoadDone) return;
-  staticLoadDone = true;
   const resolversDir = path.resolve(/*turbopackIgnore: true*/ process.cwd(), "lib/adapters/integrations/resolvers");
   try {
     const entries = await fs.readdir(resolversDir);
@@ -42,7 +40,7 @@ async function loadStaticResolversOnce() {
         if (staticLoaded.has(file)) return;
         try {
           const absolutePath = path.join(resolversDir, file);
-          await import(/*turbopackIgnore: true*/ pathToFileURL(absolutePath).href);
+          await nativeImport(pathToFileURL(absolutePath).href);
           staticLoaded.add(file);
         } catch {
           // Malformed resolver — skip silently; operator needs to fix the file

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/sandboxes/default-local-agent-host.js

@@ -34,6 +34,7 @@ import path from "node:path";
 import { registerSandboxAdapter } from "./sandbox-adapter-registry.js";
 
 const MAX_OUTPUT_BYTES = 1024 * 256;
+const TELEMETRY_MARKER = "GROWTHUB_AGENT_TELEMETRY:";
 
 /**
  * Canonical Paperclip host catalog — slugs mirror `AGENT_ADAPTER_TYPES`.
@@ -118,6 +119,134 @@ function clampStream(buffer) {
   return `${head.toString("utf8")}\n…\n[output truncated at ${MAX_OUTPUT_BYTES} bytes]`;
 }
 
+function safeNonNegativeInt(value) {
+  if (value === null || value === undefined || value === "") return null;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return null;
+  return Math.floor(n);
+}
+
+function pickFirstNumber(...values) {
+  for (const value of values) {
+    const n = safeNonNegativeInt(value);
+    if (n != null) return n;
+  }
+  return null;
+}
+
+function sumNumbers(...values) {
+  let total = 0;
+  let seen = false;
+  for (const value of values) {
+    const n = safeNonNegativeInt(value);
+    if (n == null) continue;
+    total += n;
+    seen = true;
+  }
+  return seen ? total : null;
+}
+
+function extractUsageFromObject(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return { tokens: null, tools: null };
+  const usage = (obj.usage && typeof obj.usage === "object" && !Array.isArray(obj.usage))
+    ? obj.usage
+    : (obj.token_usage && typeof obj.token_usage === "object" && !Array.isArray(obj.token_usage))
+      ? obj.token_usage
+      : (obj.metadata?.usage && typeof obj.metadata.usage === "object" && !Array.isArray(obj.metadata.usage))
+        ? obj.metadata.usage
+        : (obj.result?.usage && typeof obj.result.usage === "object" && !Array.isArray(obj.result.usage))
+          ? obj.result.usage
+          : null;
+  const tokens = usage
+    ? pickFirstNumber(
+        usage.total_tokens,
+        usage.totalTokens,
+        usage.tokens,
+        sumNumbers(usage.input_tokens, usage.output_tokens),
+        sumNumbers(usage.prompt_tokens, usage.completion_tokens),
+        sumNumbers(usage.inputTokens, usage.outputTokens),
+      )
+    : pickFirstNumber(obj.total_tokens, obj.totalTokens, obj.tokens);
+  const toolArrays = [
+    obj.tool_calls,
+    obj.toolCalls,
+    obj.toolInvocations,
+    obj.message?.tool_calls,
+    obj.choices?.[0]?.message?.tool_calls,
+    obj.result?.tool_calls,
+    obj.result?.toolCalls,
+  ].filter(Array.isArray);
+  const tools = pickFirstNumber(
+    obj.tools,
+    obj.tool_count,
+    obj.toolCount,
+    ...toolArrays.map((items) => items.length),
+  );
+  return { tokens, tools };
+}
+
+function mergeTelemetry(base, next) {
+  return {
+    tokens: base.tokens ?? next.tokens ?? null,
+    tools: base.tools ?? next.tools ?? null,
+  };
+}
+
+function parseJsonMaybe(text) {
+  const value = String(text || "").trim();
+  if (!value || !/^[\[{]/.test(value)) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function extractMarkedTelemetry(text) {
+  let out = { tokens: null, tools: null };
+  for (const line of String(text || "").split(/\r?\n/)) {
+    const idx = line.indexOf(TELEMETRY_MARKER);
+    if (idx === -1) continue;
+    const json = line.slice(idx + TELEMETRY_MARKER.length).trim();
+    const parsed = parseJsonMaybe(json);
+    out = mergeTelemetry(out, extractUsageFromObject(parsed));
+  }
+  return out;
+}
+
+function extractJsonLineTelemetry(text) {
+  let out = { tokens: null, tools: null };
+  for (const line of String(text || "").split(/\r?\n/)) {
+    const parsed = parseJsonMaybe(line);
+    if (!parsed) continue;
+    out = mergeTelemetry(out, extractUsageFromObject(parsed));
+  }
+  return out;
+}
+
+function extractStderrTextTelemetry(stderrText) {
+  const text = String(stderrText || "");
+  const total = text.match(/\b(?:total\s+tokens|tokens\s+used)\s*(?:[:=]|\r?\n)\s*([0-9][0-9,]*)/i);
+  const input = text.match(/\b(?:input|prompt)\s+tokens\s*[:=]\s*([0-9][0-9,]*)/i);
+  const output = text.match(/\b(?:output|completion)\s+tokens\s*[:=]\s*([0-9][0-9,]*)/i);
+  const tools = text.match(/\b(?:tool\s+calls?|tools\s+used)\s*[:=]\s*([0-9][0-9,]*)/i);
+  const tokens = pickFirstNumber(total?.[1]?.replace(/,/g, ""), sumNumbers(input?.[1]?.replace(/,/g, ""), output?.[1]?.replace(/,/g, "")));
+  return {
+    tokens,
+    tools: pickFirstNumber(tools?.[1]?.replace(/,/g, ""), tokens != null ? 0 : null),
+  };
+}
+
+function extractAgentHostTelemetry({ stdout, stderr }) {
+  let out = { tokens: null, tools: null };
+  const stdoutJson = parseJsonMaybe(stdout);
+  if (stdoutJson && !Array.isArray(stdoutJson)) out = mergeTelemetry(out, extractUsageFromObject(stdoutJson));
+  out = mergeTelemetry(out, extractMarkedTelemetry(stderr));
+  out = mergeTelemetry(out, extractJsonLineTelemetry(stderr));
+  out = mergeTelemetry(out, extractStderrTextTelemetry(stderr));
+  return out;
+}
+
 async function run(request) {
   const hostSlug = typeof request.agentHost === "string" ? request.agentHost.trim() : "";
   const host = HOST_CATALOG[hostSlug];
@@ -238,12 +367,15 @@ async function run(request) {
       clearTimeout(timer);
       const durationMs = Date.now() - startedAt;
       const ok = !timedOut && exitCode === 0;
+      const stdoutText = clampStream(stdout);
+      const stderrText = clampStream(stderr);
+      const telemetry = extractAgentHostTelemetry({ stdout: stdoutText, stderr: stderrText });
       resolve({
         ok,
         exitCode: typeof exitCode === "number" ? exitCode : null,
         durationMs,
-        stdout: clampStream(stdout),
-        stderr: clampStream(stderr),
+        stdout: stdoutText,
+        stderr: stderrText,
         error: timedOut
           ? `timed out after ${timeoutMs}ms`
           : (ok ? undefined : `exit ${exitCode ?? signal ?? "unknown"}`),
@@ -254,7 +386,10 @@ async function run(request) {
           argv,
           inputMode: host.inputMode,
           timedOut,
-          signal: signal || null
+          signal: signal || null,
+          tokens: telemetry.tokens,
+          tools: telemetry.tools,
+          telemetrySource: telemetry.tokens != null || telemetry.tools != null ? "agent-host-reported" : "unreported"
         }
       });
     });
@@ -281,4 +416,4 @@ registerSandboxAdapter({
   run
 });
 
-export { HOST_CATALOG, SUPPORTED_HOSTS };
+export { HOST_CATALOG, SUPPORTED_HOSTS, extractAgentHostTelemetry };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/sandboxes/default-local-intelligence.js

@@ -190,6 +190,10 @@ async function run(request) {
         endpoint,
         model,
         locality: "local",
+        // Truthful telemetry only — taken from the completion's usage block
+        // when the endpoint reports one, never estimated. Null means unknown.
+        tokens: Number.isFinite(outer?.usage?.total_tokens) ? outer.usage.total_tokens : null,
+        tools: Array.isArray(parsed.toolIntents) ? parsed.toolIntents.length : null,
       },
     };
   } catch (err) {