@geraldmaron/construct 1.0.2 → 1.0.4

package/lib/mcp/tools/telemetry.mjs

@@ -2,12 +2,13 @@
  * lib/mcp/tools/telemetry.mjs — Telemetry MCP tools: trace/score, session usage, efficiency snapshot.
  *
  * Exposes cxTrace, cxScore, sessionUsage, and efficiencySnapshot.
- * Requires ROOT_DIR injected via opts. Telemetry credentials must be in env.
+ * Requires ROOT_DIR injected via opts. Remote export uses the shared telemetry
+ * adapter when configured; local JSONL remains available by default.
  */
 import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { readFileSync, existsSync } from 'node:fs';
-import { isAvailable as telemetryAvailable } from '../../telemetry/backends/remote.mjs';
+import { createTelemetryClient } from '../../telemetry/client.mjs';
 import { summarizePromptComposition } from '../../prompt-composer.js';
 import { enrichMetadataWithPrompt } from '../../prompt-metadata.mjs';
 import { readCurrentModels, resolveExecutionContractModelMetadata, selectModelTierForWorkCategory } from '../../model-router.mjs';
@@ -16,7 +17,6 @@ import { loadWorkflow } from '../../workflow-state.mjs';
 import { buildStatus } from '../../status.mjs';
 import { readEfficiencyLog, buildCompactEfficiencyDigest } from '../../efficiency.mjs';
 import { addObservation } from '../../observation-store.mjs';
-// Local mock ingest client for fallback when ingestion service is unavailable
 import { loadConstructEnv } from '../../env-config.mjs';
 
 // Load config.env once at module init so config.env values win over shell env
@@ -34,15 +34,6 @@ function readJSON(filePath) {
 
 import { execSync as _execSync } from 'node:child_process';
 
-// Mock ingest client for fallback to direct API when the real client is not available.
-
-function getOrCreateIngestClient() {
-  return {
-    available: false,
-    trace: () => {}
-  };
-}
-
 function resolveReleaseTag(cwd) {
   try {
     return _execSync('git rev-parse --short HEAD', { stdio: 'pipe', cwd, timeout: 2000 }).toString().trim() || undefined;
@@ -51,18 +42,8 @@ function resolveReleaseTag(cwd) {
   }
 }
 
-function telemetryHeaders() {
-  const key = CONF_ENV.CONSTRUCT_TELEMETRY_PUBLIC_KEY ?? process.env.CONSTRUCT_TELEMETRY_PUBLIC_KEY;
-  const secret = CONF_ENV.CONSTRUCT_TELEMETRY_SECRET_KEY ?? process.env.CONSTRUCT_TELEMETRY_SECRET_KEY;
-  if (!key || !secret) throw new Error('CONSTRUCT_TELEMETRY_PUBLIC_KEY and CONSTRUCT_TELEMETRY_SECRET_KEY must be set.');
-  return {
-    Authorization: `Basic ${Buffer.from(`${key}:${secret}`).toString('base64')}`,
-    'Content-Type': 'application/json',
-  };
-}
-
-function telemetryBaseUrl() {
-  return (CONF_ENV.CONSTRUCT_TELEMETRY_URL ?? process.env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
+function telemetryEnv() {
+  return { ...process.env, ...CONF_ENV };
 }
 
 function resolveSessionContext() {
@@ -128,10 +109,8 @@ export async function cxTrace(args, { ROOT_DIR }) {
   }, { rootDir: ROOT_DIR });
   const traceId = args.id ?? crypto.randomUUID();
   try {
-    const available = await telemetryAvailable();
-    if (!available) return { ok: false, error: 'Telemetry credentials not configured', id: traceId };
     const teamId = args.metadata?.teamId ?? metadata.teamId;
-    const workCategoryValue = route?.workCategory ?? (typeof args.input === 'string' ? classifyWorkCategory({ request: args.input }) : null);
+    const workCategoryValue = route?.workCategory ?? null;
     const body = {
       id: traceId,
       name: args.name,
@@ -156,27 +135,17 @@ export async function cxTrace(args, { ROOT_DIR }) {
       release: ctx.release,
     };
 
-     // Add version to metadata for test compatibility
-     body.metadata.version = 'v1';
-     
-    // Use ingestion batch for creation (handles large payloads better than direct API)
-        const ingestClient = getOrCreateIngestClient();
-        if (ingestClient?.available) {
-       ingestClient.trace(body);
-       return { ok: true, id: traceId };
-     }
+    body.metadata.version = 'v1';
 
-     // Fallback: direct API call
-     const res = await fetch(`${telemetryBaseUrl()}/api/public/traces`, {
-       method: 'POST',
-       headers: telemetryHeaders(),
-       body: JSON.stringify(body),
-     });
-     if (!res.ok) {
-       const text = await res.text().catch(() => '');
-       return { ok: false, error: `Telemetry API error ${res.status}: ${text}`, id: traceId };
-     }
-     return { ok: true, id: traceId };
+    const client = createTelemetryClient({ env: telemetryEnv(), rootDir: ROOT_DIR });
+    client.trace(body);
+    await client.flush();
+    return {
+      ok: true,
+      id: traceId,
+      backend: client.backend,
+      remoteStatus: client.remoteStatus,
+    };
   } catch (err) {
     return { ok: false, error: err.message, id: traceId };
   }
@@ -193,25 +162,16 @@ export async function cxTraceUpdate(args) {
   const metadata = args.metadata;
 
   try {
-    const available = await telemetryAvailable();
-    if (!available) return { ok: false, error: 'Telemetry credentials not configured' };
-
-    const res = await fetch(`${telemetryBaseUrl()}/api/public/traces/${traceId}`, {
-      method: 'PATCH',
-      headers: telemetryHeaders(),
-      body: JSON.stringify({
-        output,
-        metadata: {
-          ...(metadata && typeof metadata === 'object' ? metadata : {}),
-          traceUpdatedAt: new Date().toISOString(),
-        },
-      }),
+    const client = createTelemetryClient({ env: telemetryEnv(), rootDir: process.cwd() });
+    client.traceUpdate({
+      id: traceId,
+      output,
+      metadata: {
+        ...(metadata && typeof metadata === 'object' ? metadata : {}),
+        traceUpdatedAt: new Date().toISOString(),
+      },
     });
-
-    if (!res.ok) {
-      const text = await res.text().catch(() => '');
-      return { ok: false, error: `Telemetry PATCH error ${res.status}: ${text}` };
-    }
+    await client.flush();
 
     // Also record as observation for local learning
     if (output || metadata) {
@@ -227,7 +187,7 @@ export async function cxTraceUpdate(args) {
       });
     }
 
-    return { ok: true, traceId };
+    return { ok: true, traceId, backend: client.backend, remoteStatus: client.remoteStatus };
   } catch (err) {
     return { ok: false, error: err.message };
   }
@@ -240,8 +200,6 @@ const SCORE_GOOD_THRESHOLD = 0.85;   // at or above this → record positive pat
 export async function cxScore(args) {
   const traceId = args.trace_id ?? '';
   try {
-    const available = await telemetryAvailable();
-    if (!available) return { ok: false, error: 'Telemetry credentials not configured' };
     const body = {
       id: crypto.randomUUID(),
       traceId,
@@ -250,15 +208,9 @@ export async function cxScore(args) {
       dataType: 'NUMERIC',
       comment: args.comment,
     };
-    const res = await fetch(`${telemetryBaseUrl()}/api/public/scores`, {
-      method: 'POST',
-      headers: telemetryHeaders(),
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => '');
-      return { ok: false, error: `Telemetry API error ${res.status}: ${text}` };
-    }
+    const client = createTelemetryClient({ env: telemetryEnv(), rootDir: process.cwd() });
+    client.score(body);
+    await client.flush();
 
     // Feed score back into the local observation store so future agents learn from it.
     // Low scores generate anti-pattern observations; high scores reinforce positive patterns.
@@ -291,7 +243,7 @@ export async function cxScore(args) {
       }
     }
 
-    return { ok: true, traceId };
+    return { ok: true, traceId, backend: client.backend, remoteStatus: client.remoteStatus };
   } catch (err) {
     return { ok: false, error: err.message };
   }

package/lib/model-cheapest-provider.mjs

@@ -0,0 +1,231 @@
+/**
+ * lib/model-cheapest-provider.mjs — cheapest configured provider selection.
+ *
+ * Evaluates all configured providers, looks up their per-tier model pricing,
+ * and returns the lowest-cost option. Local providers (Ollama, local) rank
+ * first since they are $0.
+ *
+ * Pricing data comes from getPricingForModels() in model-pricing.mjs, which
+ * has a 5-minute cache from the OpenRouter API. Static tables cover
+ * Anthropic/OpenAI first-party models.
+ *
+ * Usage:
+ *   selectCheapestProvider('standard')          // cheapest for one tier
+ *   rankConfiguredProvidersByCost('fast')       // full ranked list
+ *   isCheapestProviderEnabled()                 // check opt-in preference
+ *   formatCheapestProviderMessage(result)       // user-facing output
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { getProviderModelCatalog, PROVIDER_FAMILY_TIERS } from './model-router.mjs';
+import { getPricingForModels, formatPricingLabel } from './model-pricing.mjs';
+
+const CHEAPEST_PREF_KEY = 'CHEAPEST_PROVIDER_ENABLED';
+const CHEAPEST_CHECKED_KEY = 'CHEAPEST_PROVIDER_CHECKED';
+const ENV_PATH = path.join(os.homedir(), '.construct', 'config.env');
+
+/**
+ * Resolve the cheapest configured provider for a given tier.
+ *
+ * @param {string} tier - One of "reasoning", "standard", "fast"
+ * @param {object} [opts]
+ * @param {object} [opts.env] - Environment object (default: process.env)
+ * @param {string} [opts.envPath] - Path to config.env (default: ~/.construct/config.env)
+ * @param {Function} [opts.getPricingForModels] - Injectable pricing fetcher
+ * @returns {Promise<{
+ *   providerId: string|null,
+ *   providerLabel: string|null,
+ *   modelId: string|null,
+ *   inputPrice: number|null,
+ *   outputPrice: number|null,
+ *   isLocal: boolean,
+ *   configuredProviders: string[],
+ *   rankedList: Array<{providerId, providerLabel, modelId, inputPrice, outputPrice, totalPer1M, isLocal}>
+ * }>}
+ */
+export async function selectCheapestProvider(tier, opts = {}) {
+  if (!['reasoning', 'standard', 'fast'].includes(tier)) {
+    return { providerId: null, providerLabel: null, modelId: null, configuredProviders: [], rankedList: [] };
+  }
+
+  const env = opts.env || process.env;
+  const catalog = getProviderModelCatalog({ env });
+  const configured = catalog.providers.filter((p) => p.configured);
+
+  if (configured.length === 0) {
+    return {
+      providerId: null, providerLabel: null, modelId: null,
+      inputPrice: null, outputPrice: null, isLocal: false,
+      configuredProviders: [], rankedList: [],
+    };
+  }
+
+  // Collect tier-specific model IDs from all configured providers
+  const modelIds = [];
+  for (const p of configured) {
+    const modelId = p.tiers[tier];
+    if (modelId) modelIds.push(modelId);
+  }
+
+  const needsRemote = modelIds.filter((id) => /^openrouter\//.test(id));
+  const hasRemote = needsRemote.length > 0;
+
+  // Fetch pricing (uses 5-min cache internally)
+  let pricingMap = {};
+  if (hasRemote) {
+    try {
+      pricingMap = await getPricingForModels(modelIds, {
+        getPricingForModels: opts.getPricingForModels,
+      });
+    } catch { /* pricing unavailable — fall back to nulls */ }
+  }
+
+  // Score each provider
+  const scored = configured.map((p) => {
+    const modelId = p.tiers[tier];
+    const pricing = hasRemote ? pricingMap[modelId] : null;
+    const inputPrice = pricing ? (Number(pricing.input) || 0) : 0;
+    const outputPrice = pricing ? (Number(pricing.output) || 0) : 0;
+    return {
+      providerId: p.id,
+      providerLabel: p.label,
+      modelId,
+      inputPrice,
+      outputPrice,
+      totalPer1M: inputPrice + outputPrice,
+      isLocal: p.local === true,
+    };
+  });
+
+  // Sort ascending by total cost (local/$0 first)
+  scored.sort((a, b) => a.totalPer1M - b.totalPer1M);
+
+  const cheapest = scored[0];
+  return {
+    providerId: cheapest.providerId,
+    providerLabel: cheapest.providerLabel,
+    modelId: cheapest.modelId,
+    inputPrice: cheapest.inputPrice,
+    outputPrice: cheapest.outputPrice,
+    isLocal: cheapest.isLocal,
+    configuredProviders: configured.map((p) => p.id),
+    rankedList: scored,
+  };
+}
+
+/**
+ * Get all configured providers ranked by cost for a tier.
+ *
+ * @param {string} tier
+ * @param {object} [opts]
+ * @returns {Promise<Array<{providerId, providerLabel, modelId, inputPrice, outputPrice, totalPer1M, isLocal}>>}
+ */
+export async function rankConfiguredProvidersByCost(tier, opts = {}) {
+  const result = await selectCheapestProvider(tier, opts);
+  return result.rankedList;
+}
+
+/**
+ * Check if the user has opted into cheapest-provider selection.
+ *
+ * @param {string} [envPath] - Path to config.env (default: ~/.construct/config.env)
+ * @param {object} [opts.env] - Environment override
+ * @returns {boolean}
+ */
+export function isCheapestProviderEnabled(envPath, opts = {}) {
+  const pathToUse = envPath || ENV_PATH;
+  const env = opts.env || process.env;
+
+  // Check env var first
+  if (env[CHEAPEST_PREF_KEY]) {
+    return env[CHEAPEST_PREF_KEY].toLowerCase() === 'yes';
+  }
+
+  // Check config.env file
+  try {
+    const content = fs.readFileSync(pathToUse, 'utf8');
+    const match = content.match(new RegExp(`^${CHEAPEST_PREF_KEY}=(.+)$`, 'm'));
+    if (match) {
+      return match[1].trim().toLowerCase() === 'yes';
+    }
+  } catch { /* file doesn't exist */ }
+
+  return false;
+}
+
+/**
+ * Persist the cheapest-provider opt-in preference.
+ *
+ * @param {string} envPath - Path to config.env
+ * @param {boolean} enabled
+ */
+export function setCheapestProviderPreference(envPath, enabled) {
+  const pathToUse = envPath || ENV_PATH;
+  const existing = fs.existsSync(pathToUse) ? fs.readFileSync(pathToUse, 'utf8') : '';
+  const lines = existing.split('\n');
+  const keyLine = `${CHEAPEST_PREF_KEY}=${enabled ? 'yes' : 'no'}`;
+
+  // Replace existing key or append
+  const idx = lines.findIndex((l) => l.startsWith(`${CHEAPEST_PREF_KEY}=`));
+  if (idx >= 0) {
+    lines[idx] = keyLine;
+  } else {
+    lines.push(keyLine);
+  }
+
+  fs.mkdirSync(path.dirname(pathToUse), { recursive: true });
+  fs.writeFileSync(pathToUse, lines.join('\n'));
+}
+
+/**
+ * Format the cheapest provider selection into a user-facing message.
+ *
+ * @param {object} result - Output from selectCheapestProvider
+ * @param {object} [opts]
+ * @param {boolean} [opts.showRanking] - Include full ranked list
+ * @returns {string}
+ */
+export function formatCheapestProviderMessage(result, opts = {}) {
+  const { providerId, providerLabel, modelId, inputPrice, outputPrice, isLocal, rankedList } = result;
+
+  if (!providerId) {
+    return 'No configured providers found. Set API keys or install Ollama to enable model selection.';
+  }
+
+  const label = formatPricingLabel({ input: inputPrice, output: outputPrice, source: isLocal ? 'local' : 'openrouter' });
+  let msg = `Cheapest provider for this tier:\n`;
+  msg += `  Provider:  ${providerLabel}\n`;
+  msg += `  Model:     ${modelId}\n`;
+  msg += `  Pricing:   ${label}`;
+
+  if (opts.showRanking && rankedList && rankedList.length > 0) {
+    msg += `\n\nConfigured providers ranked by cost:\n`;
+    for (let i = 0; i < rankedList.length; i++) {
+      const r = rankedList[i];
+      const rLabel = formatPricingLabel({
+        input: r.inputPrice,
+        output: r.outputPrice,
+        source: r.isLocal ? 'local' : 'openrouter',
+      });
+      const marker = i === 0 ? '→' : ' ';
+      msg += `  ${marker} ${r.providerLabel.padEnd(28)} ${r.modelId.padEnd(40)} ${rLabel}\n`;
+    }
+  }
+
+  return msg;
+}
+
+/**
+ * Get all tier-specific cheapest selections.
+ *
+ * @param {object} [opts]
+ * @returns {Promise<{reasoning, standard, fast}>}
+ */
+export async function selectCheapestForAllTiers(opts = {}) {
+  const reasoning = await selectCheapestProvider('reasoning', opts);
+  const standard = await selectCheapestProvider('standard', opts);
+  const fast = await selectCheapestProvider('fast', opts);
+  return { reasoning, standard, fast };
+}

package/lib/model-router.mjs

@@ -45,6 +45,61 @@ export const MODEL_TIER_BY_WORK_CATEGORY = {
   analysis: "standard",
 };
 
+export const MODEL_OPERATING_PROFILES = Object.freeze({
+  balanced: {
+    id: 'balanced',
+    label: 'Balanced',
+    maxPromptTokens: 3000,
+    learnedPatternsTokens: 200,
+    taskPacketTokens: 150,
+    contextDigestTokens: 200,
+    hostConstraintsTokens: 75,
+    roleFlavorTokens: 600,
+    retrievalFirst: false,
+    preferCompressedRoleGuidance: false,
+  },
+  small: {
+    id: 'small',
+    label: 'Small-model',
+    maxPromptTokens: 1800,
+    learnedPatternsTokens: 120,
+    taskPacketTokens: 110,
+    contextDigestTokens: 120,
+    hostConstraintsTokens: 40,
+    roleFlavorTokens: 280,
+    retrievalFirst: true,
+    preferCompressedRoleGuidance: true,
+  },
+});
+
+function normalizeModelOperatingProfile(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!normalized) return null;
+  if (normalized === 'default') return 'balanced';
+  return MODEL_OPERATING_PROFILES[normalized] ? normalized : null;
+}
+
+function inferSmallModelProfile(selectedModel) {
+  const model = String(selectedModel || '').toLowerCase();
+  if (!model) return false;
+  if (/^(ollama|local)\//.test(model) && /(?:[:/-])(3b|7b|8b|13b|14b|32b)\b/.test(model)) return true;
+  if (/^(anthropic|openrouter\/anthropic)\/.*haiku/.test(model)) return true;
+  if (/gpt-5\.1-mini|gemma-3|gemma-4|phi3:mini/.test(model)) return true;
+  return false;
+}
+
+export function resolveModelOperatingProfile({
+  envValues = {},
+  selectedModel = null,
+} = {}) {
+  const explicit = normalizeModelOperatingProfile(
+    envValues.CONSTRUCT_MODEL_PROFILE ?? envValues.constructModelProfile
+  );
+  if (explicit) return MODEL_OPERATING_PROFILES[explicit];
+  if (inferSmallModelProfile(selectedModel)) return MODEL_OPERATING_PROFILES.small;
+  return MODEL_OPERATING_PROFILES.balanced;
+}
+
 /**
  * Provider-family definitions. Each entry contains:
  *   - `test`: RegExp that matches provider URLs.
@@ -217,9 +272,8 @@ const PROVIDER_FAMILY_TIERS = [
 export { PROVIDER_FAMILY_TIERS };
 
 /**
- * Map provider family IDs to the env var(s) that indicate the provider
- * is configured (has credentials). Used by getProviderModelCatalog to
- * mark which providers are available.
+ * Maps provider family IDs to the env var(s) that confirm credentials are present.
+ * Consumed by getProviderModelCatalog to mark which providers are available.
  */
 const PROVIDER_ENV_MAP = {
   'anthropic': ['ANTHROPIC_API_KEY'],
@@ -230,7 +284,7 @@ const PROVIDER_ENV_MAP = {
   'github-copilot': ['GITHUB_TOKEN', 'GH_TOKEN'],
   'openai': ['OPENAI_API_KEY'],
   'openrouter-llama': ['OPENROUTER_API_KEY', 'OPEN_ROUTER_API_KEY'],
-  'ollama': ['OLLAMA_BASE_URL'],
+  'ollama': ['OLLAMA_BASE_URL', 'OLLAMA_HOST'],
   'local': ['LOCAL_LLM_BASE_URL'],
 };
 
@@ -254,14 +308,14 @@ function isProviderConfigured(familyId, env) {
     } catch { /* not available */ }
   }
 
-  // 1. Check passed env (usually process.env)
+  // Check passed env (usually process.env)
   const anyInEnv = varNames.some(name => {
     const val = env?.[name];
     return val && typeof val === 'string' && val.length > 0;
   });
   if (anyInEnv) return true;
 
-  // 2. Check construct config.env
+  // Check construct config.env
   try {
     const homeDir = process.env.HOME || process.env.USERPROFILE || '/tmp';
     const cfgPath = path.join(homeDir, '.construct', 'config.env');
@@ -276,7 +330,7 @@ function isProviderConfigured(familyId, env) {
     }
   } catch { /* skip */ }
 
-  // 3. Special case: GitHub Copilot via gh CLI
+  // GitHub Copilot: detect via gh CLI auth status
   if (familyId === 'github-copilot') {
     try {
       const r = spawnSync('gh', ['auth', 'status'], { encoding: 'utf8', timeout: 3000 });
@@ -284,7 +338,7 @@ function isProviderConfigured(familyId, env) {
     } catch { return false; }
   }
 
-  // 4. Check ~/.env
+  // Check ~/.env
   try {
     const homeEnv = path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.env');
     if (fs.existsSync(homeEnv)) {
@@ -298,7 +352,7 @@ function isProviderConfigured(familyId, env) {
     }
   } catch { /* skip */ }
 
-  // 5. Check shell rc files for op:// refs (1Password CLI integration)
+  // Check shell rc files for op:// refs (1Password CLI integration)
   try {
     const homeDir = process.env.HOME || process.env.USERPROFILE || '/tmp';
     const shellFiles = ['.zshrc', '.bashrc', '.bash_profile', '.profile'].map(f => path.join(homeDir, f));
@@ -631,6 +685,10 @@ export function resolveExecutionContractModelMetadata({
   const tiers = resolveTierAssignments(envValues, registryModels);
   const selectedTier = requestedTier ?? selectModelTierForWorkCategory(workCategory);
   const selected = selectedTier ? tiers[selectedTier] : null;
+  const profile = resolveModelOperatingProfile({
+    envValues,
+    selectedModel: selected?.model ?? null,
+  });
 
   return {
     version: "v1",
@@ -639,6 +697,7 @@ export function resolveExecutionContractModelMetadata({
     selectedTier: selectedTier ?? null,
     selectedModel: selected?.model ?? null,
     selectedModelSource: selected?.source ?? null,
+    profile,
     tiers,
   };
 }

package/lib/ollama-manager.mjs

@@ -10,7 +10,7 @@ import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || process.env.OLLAMA_HOST || 'http://localhost:11434';
 
 /**
  * Check if Ollama is installed and running

package/lib/opencode-telemetry.mjs

@@ -5,7 +5,7 @@
  * trace/generation/span/event observations, and flushes on session.idle.
  */
 import { randomUUID } from "node:crypto";
-import { createIngestClient } from "./telemetry/ingest.mjs";
+import { createTelemetryClient } from "./telemetry/client.mjs";
 
 const SECRET_PATH_PATTERNS = [
   /(^|\/)\.env(\.|$)/i,
@@ -24,10 +24,9 @@ let cachedIngest = null;
 
 export function getIngestClient(env = process.env) {
   if (cachedIngest) return cachedIngest;
-  cachedIngest = createIngestClient({
-    baseUrl: env.CONSTRUCT_TELEMETRY_URL,
-    publicKey: env.CONSTRUCT_TELEMETRY_PUBLIC_KEY,
-    secretKey: env.CONSTRUCT_TELEMETRY_SECRET_KEY,
+  cachedIngest = createTelemetryClient({
+    env,
+    rootDir: env.CX_TOOLKIT_DIR,
     onError: (err) => {
       if (env.CONSTRUCT_TRACE_DEBUG === "1") {
         // eslint-disable-next-line no-console

package/lib/orchestration-policy.mjs

@@ -324,6 +324,14 @@ export function classifyDataEngineerFlavor(request = '') {
   return null;
 }
 
+export function classifyEngineerFlavor(request = '') {
+  const text = String(request).toLowerCase();
+  if (containsAny(text, ['llm', 'agent', 'prompt', 'eval', 'hallucination', 'rag', 'model behavior', 'model routing'])) return 'ai';
+  if (containsAny(text, ['vector', 'embedding', 'retrieval', 'warehouse', 'etl', 'elt', 'pipeline', 'streaming', 'data contract'])) return 'data';
+  if (containsAny(text, ['ci', 'build', 'deploy', 'docker', 'kubernetes', 'terraform', 'helm', 'release pipeline', 'platform tooling', 'developer experience'])) return 'platform';
+  return null;
+}
+
 export function isDataAnalysisRequest(request = '') {
   return Boolean(classifyDataAnalystFlavor(request));
 }
@@ -406,6 +414,7 @@ export function isVisualDeliverableRequest(request = '') {
 
 export function classifyRoleFlavors(request = '') {
   return {
+    engineer: classifyEngineerFlavor(request),
     architect: classifyArchitectFlavor(request),
     productManager: isProductIntelligenceRequest(request) ? classifyProductManagerFlavor(request) : null,
     qa: classifyQaFlavor(request),