chati-dev 3.3.2 → 4.0.0

package/src/terminal/prompt-builder.js

@@ -8,7 +8,7 @@
  * output format instructions.
  */
 
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { runPrism } from '../context/engine.js';
 import { loadHandoff, formatHandoff } from '../tasks/handoff.js';
@@ -16,6 +16,7 @@ import { getWriteScope } from './isolation.js';
 import { resolveOverlayPath } from '../installer/provider-overlay.js';
 import { resolveProviderForAgent } from './cli-registry.js';
 import { buildCompactGotchasSummary } from '../memory/gotchas-injector.js';
+import { estimateTokens } from './cost-tracker.js';
 
 // Import AGENT_MODELS from model-governance (safe — named export,
 // does not trigger main() which is guarded by fileURLToPath check).
@@ -39,6 +40,69 @@ export const AGENT_FILE_MAP = {
   devops: 'chati.dev/agents/deploy/devops.md',
 };
 
+/**
+ * 3-Tier Tool Mesh — Token-aware tool loading profiles per agent.
+ *
+ * T1: Core tools (always loaded) — Read, Write, Edit, Bash, Grep, Glob
+ * T2: On-demand tools (loaded when relevant) — WebSearch, WebFetch, Task
+ * T3: External MCP tools (specialized) — playwright, docker, etc.
+ *
+ * Each agent gets a customized profile based on their role to save
+ * context window budget by not loading unnecessary tool instructions.
+ */
+export const TOOL_PROFILES = {
+  'greenfield-wu': { T1: ['Read', 'Glob', 'Grep', 'Bash'], T2: ['WebSearch'], T3: [] },
+  'brownfield-wu': { T1: ['Read', 'Glob', 'Grep', 'Bash'], T2: ['WebSearch'], T3: [] },
+  brief:     { T1: ['Read', 'Glob', 'Grep'], T2: [], T3: [] },
+  detail:    { T1: ['Read', 'Write', 'Edit', 'Glob', 'Grep'], T2: [], T3: [] },
+  architect: { T1: ['Read', 'Write', 'Edit', 'Glob', 'Grep'], T2: ['WebSearch', 'WebFetch'], T3: [] },
+  ux:        { T1: ['Read', 'Write', 'Edit', 'Glob'], T2: ['WebSearch', 'WebFetch'], T3: [] },
+  phases:    { T1: ['Read', 'Write', 'Edit', 'Glob', 'Grep'], T2: [], T3: [] },
+  tasks:     { T1: ['Read', 'Write', 'Edit', 'Glob', 'Grep'], T2: [], T3: [] },
+  'qa-planning': { T1: ['Read', 'Glob', 'Grep'], T2: [], T3: [] },
+  dev:       { T1: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep'], T2: ['WebSearch', 'WebFetch', 'Task'], T3: ['playwright'] },
+  'qa-implementation': { T1: ['Read', 'Bash', 'Glob', 'Grep'], T2: ['Task'], T3: [] },
+  devops:    { T1: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep'], T2: ['WebSearch'], T3: ['docker'] },
+};
+
+/**
+ * Get the tool profile for an agent.
+ *
+ * @param {string} agent - Agent name
+ * @returns {{ T1: string[], T2: string[], T3: string[] }}
+ */
+export function getToolProfile(agent) {
+  return TOOL_PROFILES[agent] || { T1: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep'], T2: [], T3: [] };
+}
+
+/**
+ * Build tool mesh section for prompt injection.
+ *
+ * @param {string} agent - Agent name
+ * @returns {string} Formatted tool mesh instructions
+ */
+export function buildToolMeshSection(agent) {
+  const profile = getToolProfile(agent);
+  const lines = [
+    '<!-- TOOL MESH -->',
+    '## Available Tools',
+    '',
+    `**Core (T1)**: ${profile.T1.join(', ')}`,
+  ];
+
+  if (profile.T2.length > 0) {
+    lines.push(`**On-demand (T2)**: ${profile.T2.join(', ')} — use only when needed`);
+  }
+
+  if (profile.T3.length > 0) {
+    lines.push(`**External (T3)**: ${profile.T3.join(', ')} — available via MCP if configured`);
+  }
+
+  lines.push('', 'Prefer T1 tools for all standard operations. Use T2/T3 only when the task requires them.');
+
+  return lines.join('\n');
+}
+
 /**
  * @typedef {object} PromptBuildConfig
  * @property {string} agent           - Agent name (e.g. 'detail')
@@ -127,6 +191,9 @@ export function buildAgentPrompt(config) {
 
   const prompt = sections.join('\n\n---\n\n');
 
+  // 10. Prompt size guard — validate before returning
+  const sizeCheck = validatePromptSize(prompt, resolvedProvider);
+
   return {
     prompt,
     model,
@@ -135,6 +202,7 @@ export function buildAgentPrompt(config) {
       agent: config.agent,
       layers: prismResult.layerCount || 0,
       promptSize: prompt.length,
+      sizeCheck,
     },
   };
 }
@@ -176,6 +244,7 @@ function buildPrismSection(config) {
     handoff,
     artifacts: state.artifacts || [],
     taskCriteria: [],
+    userPrompt: config.additionalContext || null,
   });
 
   return {
@@ -292,6 +361,277 @@ function buildSessionSection(config, resolvedModelInfo = {}) {
   return lines.join('\n');
 }
 
+// ---------------------------------------------------------------------------
+// Prompt Size Guard
+// ---------------------------------------------------------------------------
+
+/**
+ * Provider-specific token limits for prompt size validation.
+ */
+const PROVIDER_TOKEN_LIMITS = {
+  claude: 200_000,
+  gemini: 1_000_000,
+  codex: 128_000,
+};
+
+/**
+ * Validate prompt size against provider-specific limits.
+ *
+ * @param {string} prompt - The assembled prompt string
+ * @param {string} [provider='claude'] - Provider name for limit lookup
+ * @returns {{ valid: boolean, level: string, ratio: number, estimatedTokens: number, limit: number, message: string|null }}
+ */
+export function validatePromptSize(prompt, provider = 'claude') {
+  const limit = PROVIDER_TOKEN_LIMITS[provider] || PROVIDER_TOKEN_LIMITS.claude;
+  const tokens = estimateTokens(prompt);
+  const ratio = tokens / limit;
+
+  if (ratio >= 0.9) {
+    return {
+      valid: false,
+      level: 'error',
+      ratio: Math.round(ratio * 100) / 100,
+      estimatedTokens: tokens,
+      limit,
+      message: `Prompt size (${tokens} tokens) exceeds 90% of ${provider} limit (${limit}). Prompt may be truncated or rejected.`,
+    };
+  }
+
+  if (ratio >= 0.7) {
+    return {
+      valid: true,
+      level: 'warning',
+      ratio: Math.round(ratio * 100) / 100,
+      estimatedTokens: tokens,
+      limit,
+      message: `Prompt size (${tokens} tokens) exceeds 70% of ${provider} limit (${limit}). Consider reducing context.`,
+    };
+  }
+
+  return {
+    valid: true,
+    level: 'ok',
+    ratio: Math.round(ratio * 100) / 100,
+    estimatedTokens: tokens,
+    limit,
+    message: null,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tech Presets
+// ---------------------------------------------------------------------------
+
+/**
+ * Load a tech preset YAML file by stack name.
+ *
+ * @param {string} stack - Stack identifier (e.g., 'nextjs', 'react-vite')
+ * @param {string} projectDir - Project root directory
+ * @returns {{ loaded: boolean, preset: object|null, stack: string }}
+ */
+export function loadPreset(stack, projectDir) {
+  if (!stack || !projectDir) {
+    return { loaded: false, preset: null, stack: stack || '' };
+  }
+
+  // Check both deployed (chati.dev/presets/) and package (framework/presets/) locations
+  const locations = [
+    join(projectDir, 'chati.dev', 'presets'),
+    join(projectDir, 'framework', 'presets'),
+  ];
+
+  for (const presetsDir of locations) {
+    const presetPath = join(presetsDir, `${stack}.yaml`);
+    if (!existsSync(presetPath)) continue;
+
+    try {
+      const raw = readFileSync(presetPath, 'utf-8');
+      const preset = parsePresetYaml(raw);
+      return { loaded: true, preset, stack };
+    } catch {
+      continue;
+    }
+  }
+
+  return { loaded: false, preset: null, stack };
+}
+
+/**
+ * Detect which tech preset to load based on project files.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {string|null} Detected stack name or null
+ */
+export function detectPreset(projectDir) {
+  if (!projectDir) return null;
+
+  // Check both deployed and package locations
+  const locations = [
+    join(projectDir, 'chati.dev', 'presets'),
+    join(projectDir, 'framework', 'presets'),
+  ];
+
+  let presetsDir = null;
+  for (const loc of locations) {
+    if (existsSync(loc)) { presetsDir = loc; break; }
+  }
+  if (!presetsDir) return null;
+
+  // List all preset files
+  let presetFiles;
+  try {
+    presetFiles = readdirSync(presetsDir).filter(f => f.endsWith('.yaml'));
+  } catch {
+    return null;
+  }
+
+  // Check package.json dependencies
+  const pkgPath = join(projectDir, 'package.json');
+  let pkgContent = '';
+  if (existsSync(pkgPath)) {
+    try { pkgContent = readFileSync(pkgPath, 'utf-8'); } catch { /* ignore */ }
+  }
+
+  // Check for detection markers in project root
+  for (const file of presetFiles) {
+    const raw = readFileSync(join(presetsDir, file), 'utf-8');
+    const preset = parsePresetYaml(raw);
+    if (!preset.detection || !Array.isArray(preset.detection)) continue;
+
+    for (const marker of preset.detection) {
+      // Check if marker is a file that exists in the project
+      if (existsSync(join(projectDir, marker))) {
+        return preset.stack || file.replace('.yaml', '');
+      }
+      // Check if marker is a dependency
+      if (pkgContent && pkgContent.includes(`"${marker}"`)) {
+        return preset.stack || file.replace('.yaml', '');
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Parse a preset YAML file into a structured object.
+ * Uses lightweight regex parsing consistent with the framework.
+ *
+ * @param {string} raw - Raw YAML content
+ * @returns {object} Parsed preset
+ */
+export function parsePresetYaml(raw) {
+  const preset = {
+    stack: '',
+    displayName: '',
+    detection: [],
+    conventions: {},
+    structure: [],
+    rules: [],
+  };
+
+  // stack:
+  const stackMatch = raw.match(/^stack:\s*(.+)$/m);
+  if (stackMatch) preset.stack = stackMatch[1].trim();
+
+  // displayName:
+  const nameMatch = raw.match(/^displayName:\s*"?([^"\n]+)"?$/m);
+  if (nameMatch) preset.displayName = nameMatch[1].trim();
+
+  // detection: (array)
+  const detectionMatch = raw.match(/^detection:\s*\n((?:\s+-\s*.+\n?)*)/m);
+  if (detectionMatch) {
+    const items = detectionMatch[1].matchAll(/^\s+-\s*"?([^"\n]+)"?\s*$/gm);
+    for (const item of items) {
+      preset.detection.push(item[1].trim());
+    }
+  }
+
+  // conventions: (key-value map)
+  const convMatch = raw.match(/^conventions:\s*\n((?:\s+\w[\w]*:\s*.+\n?)*)/m);
+  if (convMatch) {
+    const pairs = convMatch[1].matchAll(/^\s+(\w[\w]*):\s*"?([^"\n]+)"?\s*$/gm);
+    for (const pair of pairs) {
+      preset.conventions[pair[1].trim()] = pair[2].trim();
+    }
+  }
+
+  // structure: (array of strings)
+  const structMatch = raw.match(/^structure:\s*\n((?:\s+-\s*.+\n?)*)/m);
+  if (structMatch) {
+    const items = structMatch[1].matchAll(/^\s+-\s*"?([^"\n]+)"?\s*$/gm);
+    for (const item of items) {
+      preset.structure.push(item[1].trim());
+    }
+  }
+
+  // rules: (array of objects with id, text, priority)
+  const rulesMatch = raw.match(/^rules:\s*\n((?:\s+-.+\n(?:\s+\w.+\n?)*)*)/m);
+  if (rulesMatch) {
+    const ruleBlocks = rulesMatch[1].split(/(?=\s+-\s+id:)/);
+    for (const block of ruleBlocks) {
+      const idMatch = block.match(/id:\s*(\S+)/);
+      const textMatch = block.match(/text:\s*"?([^"\n]+)"?/);
+      const prioMatch = block.match(/priority:\s*(\S+)/);
+      if (idMatch && textMatch) {
+        preset.rules.push({
+          id: idMatch[1],
+          text: textMatch[1].trim(),
+          priority: prioMatch ? prioMatch[1] : 'normal',
+        });
+      }
+    }
+  }
+
+  return preset;
+}
+
+/**
+ * Build a formatted preset section for prompt injection.
+ *
+ * @param {object} preset - Parsed preset object
+ * @returns {string} Formatted preset section
+ */
+export function buildPresetSection(preset) {
+  if (!preset) return '';
+
+  const lines = [
+    '<!-- TECH PRESET -->',
+    `## Tech Preset: ${preset.displayName || preset.stack}`,
+    '',
+  ];
+
+  // Conventions
+  if (preset.conventions && Object.keys(preset.conventions).length > 0) {
+    lines.push('### Conventions');
+    for (const [key, value] of Object.entries(preset.conventions)) {
+      lines.push(`- **${key}**: ${value}`);
+    }
+    lines.push('');
+  }
+
+  // Structure
+  if (preset.structure && preset.structure.length > 0) {
+    lines.push('### Expected Structure');
+    for (const item of preset.structure) {
+      lines.push(`- ${item}`);
+    }
+    lines.push('');
+  }
+
+  // Rules
+  if (preset.rules && preset.rules.length > 0) {
+    lines.push('### Rules');
+    for (const rule of preset.rules) {
+      const badge = rule.priority === 'critical' ? '[CRITICAL]' : rule.priority === 'high' ? '[HIGH]' : '';
+      lines.push(`- ${badge ? badge + ' ' : ''}${rule.text}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
 /**
  * Build output format instructions so the agent produces a parseable handoff.
  */

package/src/terminal/run-agent.js

@@ -18,6 +18,7 @@ import { buildAgentPrompt } from './prompt-builder.js';
 import { spawnTerminal } from './spawner.js';
 import { parseAgentOutput } from './handoff-parser.js';
 import { createCostTracker } from './cost-tracker.js';
+import { getRateLimiter } from './rate-limiter.js';
 import { initCollector, track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
 import { sendEvents } from '../telemetry/sender.js';
 import { getTelemetryConfig, isEnabled as isTelemetryEnabled } from '../telemetry/config.js';
@@ -99,6 +100,20 @@ async function main() {
     process.exit(1);
   }
 
+  // Wait for rate limit slot before spawning
+  const spawnProvider = promptResult.provider || args.provider || 'claude';
+  const limiter = getRateLimiter(spawnProvider);
+  if (!limiter.canSpawn()) {
+    const rateLimitStart = Date.now();
+    await limiter.waitForSlot();
+    const rateLimitWait = Date.now() - rateLimitStart;
+    telemetryTrack('rate_limit_wait', {
+      agent: args.agent,
+      provider: spawnProvider,
+      waitMs: rateLimitWait,
+    });
+  }
+
   // Spawn the agent terminal
   const startTime = Date.now();
   let handle;

package/src/terminal/run-parallel.js

@@ -16,11 +16,12 @@
 
 import { fileURLToPath } from 'url';
 import { buildAgentPrompt } from './prompt-builder.js';
-import { spawnParallelGroup } from './spawner.js';
+import { spawnParallelGroup, spawnTerminal } from './spawner.js';
 import { TerminalMonitor } from './monitor.js';
 import { collectResults, mergeHandoffs, buildConsolidatedHandoff } from './collector.js';
 import { parseAgentOutput } from './handoff-parser.js';
 import { estimateTokens, COST_PER_1K } from './cost-tracker.js';
+import { getRateLimiter } from './rate-limiter.js';
 
 // ---------------------------------------------------------------------------
 // CLI argument parsing
@@ -119,13 +120,29 @@ async function main() {
     }
   }
 
-  // Spawn all terminals in parallel
+  // Check rate limit capacity before spawning
+  const groupProvider = configs[0]?.provider || 'claude';
+  const limiter = getRateLimiter(groupProvider);
+  const rateStats = limiter.getStats();
+  const availableSlots = rateStats.limit - rateStats.used;
+  if (availableSlots < configs.length) {
+    console.error(`[chati] Rate limiter: ${availableSlots} slots available for ${configs.length} agents. Spawns may be throttled.`);
+  }
+
+  // Spawn all terminals in parallel (with sequential fallback)
   let group;
+  let fallbackUsed = false;
   try {
     group = spawnParallelGroup(configs);
   } catch (err) {
-    outputError(`Failed to spawn parallel group: ${err.message}`);
-    process.exit(1);
+    console.error(`[chati] Parallel spawn failed: ${err.message}. Falling back to sequential execution.`);
+    try {
+      group = await sequentialFallback(configs, timeout);
+      fallbackUsed = true;
+    } catch (fallbackErr) {
+      outputError(`Sequential fallback also failed: ${fallbackErr.message}`);
+      process.exit(1);
+    }
   }
 
   // Monitor until completion
@@ -218,6 +235,7 @@ async function main() {
       timeSaved: elapsed * (agents.length - 1),
     },
     costEstimate: costEstimates,
+    fallbackUsed,
   };
 
   process.stdout.write(JSON.stringify(output, null, 2) + '\n');
@@ -228,6 +246,60 @@ async function main() {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Sequential fallback: spawn agents one at a time when parallel spawning fails.
+ * Produces the same group structure as spawnParallelGroup for transparent handling.
+ *
+ * @param {object[]} configs - Agent spawn configurations
+ * @param {number} timeout - Per-agent timeout in ms
+ * @returns {Promise<{ groupId: string, terminals: object[] }>}
+ */
+async function sequentialFallback(configs, timeout) {
+  const groupId = `seq-fallback-${Date.now()}`;
+  const terminals = [];
+
+  for (let i = 0; i < configs.length; i++) {
+    const cfg = configs[i];
+    const terminal = spawnTerminal({
+      agent: cfg.agent,
+      taskId: cfg.taskId,
+      model: cfg.model,
+      provider: cfg.provider,
+      prompt: cfg.prompt,
+      workingDir: cfg.workingDir,
+      timeout: cfg.timeout || timeout,
+    });
+
+    // Wait for this terminal to finish before spawning the next
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        terminal.kill?.();
+        resolve();
+      }, (cfg.timeout || timeout) + 5_000);
+
+      terminal.onExit?.(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+
+      // If terminal doesn't have onExit, resolve after a short poll
+      if (!terminal.onExit) {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+
+    terminals.push(terminal);
+
+    // Small delay between spawns to avoid rate limit pressure
+    if (i < configs.length - 1) {
+      await new Promise(r => setTimeout(r, 500));
+    }
+  }
+
+  return { groupId, terminals };
+}
+
 /**
  * Determine the next sequential agent after a parallel group.
  * GROUP 1 (detail+architect+ux) → phases
@@ -256,4 +328,4 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
   });
 }
 
-export { parseArgs, determineNextAgent };
+export { parseArgs, determineNextAgent, sequentialFallback };

package/src/terminal/spawner.js

@@ -10,6 +10,7 @@
 import { spawn } from 'child_process';
 import { validateWriteScopes, buildIsolationEnv } from './isolation.js';
 import { getProvider } from './cli-registry.js';
+import { getRateLimiter } from './rate-limiter.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -234,6 +235,10 @@ export function spawnTerminal(config) {
     timeout,
   };
 
+  // Record spawn in rate limiter for throttling
+  const providerForRate = config.provider || 'claude';
+  getRateLimiter(providerForRate).recordSpawn();
+
   // Capture output (capped at ~10MB to prevent unbounded memory growth)
   const MAX_BUFFER_CHUNKS = 10_000;
   if (child.stdout) {
@@ -297,6 +302,14 @@ export function spawnParallelGroup(configs) {
     throw new Error(`Write scope conflicts detected: ${details}`);
   }
 
+  // Preemptive rate limit capacity check
+  const groupProvider = configs[0]?.provider || 'claude';
+  const limiter = getRateLimiter(groupProvider);
+  const stats = limiter.getStats();
+  if (stats.used + configs.length > stats.limit) {
+    console.error(`[chati] Rate limit warning: ${stats.used}/${stats.limit} slots used, requesting ${configs.length} more`);
+  }
+
   const groupId = `group-${Date.now()}`;
   const terminals = configs.map(cfg => spawnTerminal(cfg));
 

package/src/utils/feature-flags.js

@@ -0,0 +1,106 @@
+/**
+ * @fileoverview Feature flag reader for chati.dev framework.
+ *
+ * Reads the `features:` section from config.yaml and returns boolean
+ * values for each feature toggle. All features default to false when
+ * not explicitly set.
+ *
+ * Uses lightweight regex-based parsing consistent with config-parser.js.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * All known feature flags with their default values.
+ * New features start as false (opt-in).
+ */
+const DEFAULTS = {
+  hybrid_budget: false,
+  anti_dash: false,
+  rate_limiter_integration: false,
+  l5_keywords: false,
+  prompt_size_guard: false,
+  ids_decision_engine: false,
+  surface_criteria: false,
+  parallel_fallback: false,
+  tool_mesh: false,
+  tech_presets: false,
+  doctor_autofix: false,
+  brandbook: false,
+};
+
+/**
+ * Check if a specific feature is enabled.
+ *
+ * @param {string} projectDir - Project root directory (contains chati.dev/)
+ * @param {string} featureName - Feature flag name (e.g., 'hybrid_budget')
+ * @returns {boolean} True if feature is enabled, false otherwise
+ */
+export function isFeatureEnabled(projectDir, featureName) {
+  const features = getEnabledFeatures(projectDir);
+  return features[featureName] ?? DEFAULTS[featureName] ?? false;
+}
+
+/**
+ * Get all feature flags with their current values.
+ *
+ * @param {string} projectDir - Project root directory (contains chati.dev/)
+ * @returns {Record<string, boolean>} Map of feature name to enabled status
+ */
+export function getEnabledFeatures(projectDir) {
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) {
+    return { ...DEFAULTS };
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  return parseFeaturesSection(raw);
+}
+
+/**
+ * Parse the features section from raw config.yaml content.
+ *
+ * @param {string} raw - Raw YAML content
+ * @returns {Record<string, boolean>} Parsed feature flags merged with defaults
+ */
+export function parseFeaturesSection(raw) {
+  const result = { ...DEFAULTS };
+
+  // Find the features: block
+  const featuresMatch = raw.match(/^features:\s*\n((?:\s+\w[\w]*:\s*.+\n?)*)/m);
+  if (!featuresMatch) return result;
+
+  const block = featuresMatch[1];
+
+  // Extract each key: value pair
+  const linePattern = /^\s+(\w[\w]*):\s*(true|false)\s*$/gm;
+  let match;
+  while ((match = linePattern.exec(block)) !== null) {
+    const key = match[1];
+    const value = match[2] === 'true';
+    if (key in result) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get the list of known feature flag names.
+ *
+ * @returns {string[]} Array of feature flag names
+ */
+export function getFeatureNames() {
+  return Object.keys(DEFAULTS);
+}
+
+/**
+ * Get default values for all feature flags.
+ *
+ * @returns {Record<string, boolean>} Default feature flag values
+ */
+export function getDefaults() {
+  return { ...DEFAULTS };
+}