chati-dev 3.3.2 → 4.0.1

package/src/intelligence/decision-engine.js

@@ -0,0 +1,253 @@
+/**
+ * IDS Decision Engine — Intelligent Deduplication & Similarity scoring.
+ *
+ * Before creating any new artifact, scores existing registry entities
+ * for similarity. Enforces Constitution Article XIV: REUSE > ADAPT > CREATE.
+ *
+ * Algorithm:
+ *   similarity = (keywordOverlap * 0.6) + (purposeSimilarity * 0.4)
+ *   >= 90% → REUSE, 60-89% → ADAPT, < 60% → CREATE
+ */
+
+import { existsSync, readFileSync } from 'fs';
+
+
+/**
+ * @typedef {object} DecisionIntent
+ * @property {string[]} keywords - Keywords describing what we want to create
+ * @property {string} purpose - One-line description of the intended artifact
+ */
+
+/**
+ * @typedef {object} DecisionResult
+ * @property {string} decision - 'REUSE' | 'ADAPT' | 'CREATE'
+ * @property {string|null} matchId - The best matching entity ID (null for CREATE)
+ * @property {number} similarity - 0-100 similarity score
+ * @property {string} reasoning - Human-readable explanation
+ * @property {object|null} match - The best matching entity data
+ */
+
+/**
+ * Evaluate a creation intent against the entity registry.
+ *
+ * @param {DecisionIntent} intent - What we want to create
+ * @param {string} registryPath - Absolute path to entity-registry.yaml
+ * @returns {DecisionResult}
+ */
+export function evaluateDecision(intent, registryPath) {
+  if (!intent || !intent.keywords || !intent.purpose) {
+    return {
+      decision: 'CREATE',
+      matchId: null,
+      similarity: 0,
+      reasoning: 'No intent provided, defaulting to CREATE.',
+      match: null,
+    };
+  }
+
+  const entities = loadRegistryEntities(registryPath);
+  if (entities.length === 0) {
+    return {
+      decision: 'CREATE',
+      matchId: null,
+      similarity: 0,
+      reasoning: 'Registry empty or not found, defaulting to CREATE.',
+      match: null,
+    };
+  }
+
+  let bestMatch = null;
+  let bestScore = 0;
+  let bestId = null;
+
+  for (const entity of entities) {
+    const score = calculateSimilarity(intent, entity);
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = entity;
+      bestId = entity.id;
+    }
+  }
+
+  const similarity = Math.round(bestScore * 100);
+  let decision;
+  let reasoning;
+
+  if (similarity >= 90) {
+    decision = 'REUSE';
+    reasoning = `Entity "${bestId}" is ${similarity}% similar. Reuse as-is (Article XIV).`;
+  } else if (similarity >= 60) {
+    decision = 'ADAPT';
+    reasoning = `Entity "${bestId}" is ${similarity}% similar. Adapt for current needs (adaptability: ${bestMatch?.adaptability ?? 'unknown'}).`;
+  } else {
+    decision = 'CREATE';
+    reasoning = bestId
+      ? `Best match "${bestId}" is only ${similarity}% similar. Create new artifact.`
+      : 'No sufficiently similar entity found. Create new artifact.';
+  }
+
+  return {
+    decision,
+    matchId: similarity >= 60 ? bestId : null,
+    similarity,
+    reasoning,
+    match: similarity >= 60 ? bestMatch : null,
+  };
+}
+
+/**
+ * Calculate combined similarity between an intent and an entity.
+ *
+ * similarity = (keywordOverlap * 0.6) + (purposeSimilarity * 0.4)
+ *
+ * @param {DecisionIntent} intent
+ * @param {{ keywords: string[], purpose: string }} entity
+ * @returns {number} 0.0 to 1.0
+ */
+export function calculateSimilarity(intent, entity) {
+  const kwScore = keywordOverlap(intent.keywords, entity.keywords || []);
+  const purposeScore = purposeSimilarity(intent.purpose, entity.purpose || '');
+  return (kwScore * 0.6) + (purposeScore * 0.4);
+}
+
+/**
+ * Calculate keyword overlap using token-based Jaccard similarity.
+ *
+ * @param {string[]} a - Intent keywords
+ * @param {string[]} b - Entity keywords
+ * @returns {number} 0.0 to 1.0
+ */
+export function keywordOverlap(a, b) {
+  if (!a || !b || a.length === 0 || b.length === 0) return 0;
+
+  const setA = new Set(a.map(k => k.toLowerCase().trim()));
+  const setB = new Set(b.map(k => k.toLowerCase().trim()));
+
+  let intersection = 0;
+  for (const k of setA) {
+    if (setB.has(k)) intersection++;
+  }
+
+  const union = new Set([...setA, ...setB]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Calculate purpose similarity using token overlap (bag-of-words).
+ *
+ * @param {string} a - Intent purpose
+ * @param {string} b - Entity purpose
+ * @returns {number} 0.0 to 1.0
+ */
+export function purposeSimilarity(a, b) {
+  if (!a || !b) return 0;
+
+  const tokenize = (text) => {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, '')
+      .split(/\s+/)
+      .filter(t => t.length > 2); // Skip tiny words
+  };
+
+  const tokensA = new Set(tokenize(a));
+  const tokensB = new Set(tokenize(b));
+
+  if (tokensA.size === 0 || tokensB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const t of tokensA) {
+    if (tokensB.has(t)) intersection++;
+  }
+
+  const union = new Set([...tokensA, ...tokensB]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Load and flatten entity registry into a searchable array.
+ *
+ * @param {string} registryPath - Absolute path to entity-registry.yaml
+ * @returns {Array<{ id: string, keywords: string[], purpose: string, path: string, type: string, adaptability: number }>}
+ */
+export function loadRegistryEntities(registryPath) {
+  if (!registryPath || !existsSync(registryPath)) return [];
+
+  try {
+    const raw = readFileSync(registryPath, 'utf-8');
+    return parseRegistryEntities(raw);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Parse registry YAML into flat entity array.
+ * Uses simple regex parsing consistent with the codebase pattern.
+ *
+ * @param {string} raw - Raw YAML content
+ * @returns {Array<{ id: string, keywords: string[], purpose: string, path: string, type: string, adaptability: number }>}
+ */
+export function parseRegistryEntities(raw) {
+  const entities = [];
+  const lines = raw.split('\n');
+
+  let currentCategory = null;
+  let currentEntity = null;
+  let currentData = {};
+
+  for (const line of lines) {
+    // Category header (agents:, templates:, etc.) — 2-space indent under entities:
+    const categoryMatch = line.match(/^ {2}(\w[\w-]*):\s*$/);
+    if (categoryMatch && !line.match(/^\s{4}/)) {
+      // Save previous entity
+      if (currentEntity && currentData.purpose) {
+        entities.push({ id: `${currentCategory}/${currentEntity}`, ...currentData });
+      }
+      currentCategory = categoryMatch[1];
+      currentEntity = null;
+      currentData = {};
+      continue;
+    }
+
+    // Entity header (e.g., "    orchestrator:") — 4-space indent
+    const entityMatch = line.match(/^ {4}([\w][\w-]*):\s*$/);
+    if (entityMatch) {
+      // Save previous entity
+      if (currentEntity && currentData.purpose) {
+        entities.push({ id: `${currentCategory}/${currentEntity}`, ...currentData });
+      }
+      currentEntity = entityMatch[1];
+      currentData = { keywords: [], purpose: '', path: '', type: '', adaptability: 0.5 };
+      continue;
+    }
+
+    if (!currentEntity) continue;
+
+    // Entity fields (6-space indent)
+    const pathMatch = line.match(/^\s{6}path:\s*(.+)/);
+    if (pathMatch) { currentData.path = pathMatch[1].trim(); continue; }
+
+    const typeMatch = line.match(/^\s{6}type:\s*(.+)/);
+    if (typeMatch) { currentData.type = typeMatch[1].trim(); continue; }
+
+    const purposeMatch = line.match(/^\s{6}purpose:\s*"?([^"]*)"?\s*$/);
+    if (purposeMatch) { currentData.purpose = purposeMatch[1].trim(); continue; }
+
+    const adaptMatch = line.match(/^\s{6}adaptability:\s*([\d.]+)/);
+    if (adaptMatch) { currentData.adaptability = parseFloat(adaptMatch[1]); continue; }
+
+    const kwMatch = line.match(/^\s{6}keywords:\s*\[(.+)\]/);
+    if (kwMatch) {
+      currentData.keywords = kwMatch[1].split(',').map(k => k.trim().replace(/^['"]|['"]$/g, ''));
+      continue;
+    }
+  }
+
+  // Save last entity
+  if (currentEntity && currentData.purpose) {
+    entities.push({ id: `${currentCategory}/${currentEntity}`, ...currentData });
+  }
+
+  return entities;
+}

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;