claude-code-workflow 6.3.13 → 6.3.16

package/ccw/src/core/routes/issue-routes.ts

@@ -67,6 +67,17 @@ function readSolutionsJsonl(issuesDir: string, issueId: string): any[] {
   }
 }
 
+function readIssueHistoryJsonl(issuesDir: string): any[] {
+  const historyPath = join(issuesDir, 'issue-history.jsonl');
+  if (!existsSync(historyPath)) return [];
+  try {
+    const content = readFileSync(historyPath, 'utf8');
+    return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
 function writeSolutionsJsonl(issuesDir: string, issueId: string, solutions: any[]) {
   const solutionsDir = join(issuesDir, 'solutions');
   if (!existsSync(solutionsDir)) mkdirSync(solutionsDir, { recursive: true });
@@ -109,7 +120,18 @@ function readQueue(issuesDir: string) {
 
 function writeQueue(issuesDir: string, queue: any) {
   if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
-  queue._metadata = { ...queue._metadata, updated_at: new Date().toISOString(), total_tasks: queue.tasks?.length || 0 };
+
+  // Support both solution-based and task-based queues
+  const items = queue.solutions || queue.tasks || [];
+  const isSolutionBased = Array.isArray(queue.solutions) && queue.solutions.length > 0;
+
+  queue._metadata = {
+    ...queue._metadata,
+    updated_at: new Date().toISOString(),
+    ...(isSolutionBased
+      ? { total_solutions: items.length }
+      : { total_tasks: items.length })
+  };
 
   // Check if using new multi-queue structure
   const queuesDir = join(issuesDir, 'queues');
@@ -125,8 +147,13 @@ function writeQueue(issuesDir: string, queue: any) {
       const index = JSON.parse(readFileSync(indexPath, 'utf8'));
       const queueEntry = index.queues?.find((q: any) => q.id === queue.id);
       if (queueEntry) {
-        queueEntry.total_tasks = queue.tasks?.length || 0;
-        queueEntry.completed_tasks = queue.tasks?.filter((i: any) => i.status === 'completed').length || 0;
+        if (isSolutionBased) {
+          queueEntry.total_solutions = items.length;
+          queueEntry.completed_solutions = items.filter((i: any) => i.status === 'completed').length;
+        } else {
+          queueEntry.total_tasks = items.length;
+          queueEntry.completed_tasks = items.filter((i: any) => i.status === 'completed').length;
+        }
         writeFileSync(indexPath, JSON.stringify(index, null, 2));
       }
     } catch {
@@ -173,9 +200,26 @@ function enrichIssues(issues: any[], issuesDir: string) {
   });
 }
 
+/**
+ * Get queue items (supports both solution-based and task-based queues)
+ */
+function getQueueItems(queue: any): any[] {
+  return queue.solutions || queue.tasks || [];
+}
+
+/**
+ * Check if queue is solution-based
+ */
+function isSolutionBasedQueue(queue: any): boolean {
+  return Array.isArray(queue.solutions) && queue.solutions.length > 0;
+}
+
 function groupQueueByExecutionGroup(queue: any) {
   const groups: { [key: string]: any[] } = {};
-  for (const item of queue.tasks || []) {
+  const items = getQueueItems(queue);
+  const isSolutionBased = isSolutionBasedQueue(queue);
+
+  for (const item of items) {
     const groupId = item.execution_group || 'ungrouped';
     if (!groups[groupId]) groups[groupId] = [];
     groups[groupId].push(item);
@@ -183,11 +227,13 @@ function groupQueueByExecutionGroup(queue: any) {
   for (const groupId of Object.keys(groups)) {
     groups[groupId].sort((a, b) => (a.execution_order || 0) - (b.execution_order || 0));
   }
-  const executionGroups = Object.entries(groups).map(([id, items]) => ({
+  const executionGroups = Object.entries(groups).map(([id, groupItems]) => ({
     id,
     type: id.startsWith('P') ? 'parallel' : id.startsWith('S') ? 'sequential' : 'unknown',
-    task_count: items.length,
-    tasks: items.map(i => i.item_id)
+    // Use appropriate count field based on queue type
+    ...(isSolutionBased
+      ? { solution_count: groupItems.length, solutions: groupItems.map(i => i.item_id) }
+      : { task_count: groupItems.length, tasks: groupItems.map(i => i.item_id) })
   })).sort((a, b) => {
     const aFirst = groups[a.id]?.[0]?.execution_order || 0;
     const bFirst = groups[b.id]?.[0]?.execution_order || 0;
@@ -312,7 +358,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // POST /api/queue/reorder - Reorder queue items
+  // POST /api/queue/reorder - Reorder queue items (supports both solutions and tasks)
   if (pathname === '/api/queue/reorder' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
       const { groupId, newOrder } = body;
@@ -321,8 +367,11 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
       }
 
       const queue = readQueue(issuesDir);
-      const groupItems = queue.tasks.filter((item: any) => item.execution_group === groupId);
-      const otherItems = queue.tasks.filter((item: any) => item.execution_group !== groupId);
+      const items = getQueueItems(queue);
+      const isSolutionBased = isSolutionBasedQueue(queue);
+
+      const groupItems = items.filter((item: any) => item.execution_group === groupId);
+      const otherItems = items.filter((item: any) => item.execution_group !== groupId);
 
       if (groupItems.length === 0) return { error: `No items in group ${groupId}` };
 
@@ -336,7 +385,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
 
       const itemMap = new Map(groupItems.map((i: any) => [i.item_id, i]));
       const reorderedItems = newOrder.map((qid: string, idx: number) => ({ ...itemMap.get(qid), _idx: idx }));
-      const newQueue = [...otherItems, ...reorderedItems].sort((a, b) => {
+      const newQueueItems = [...otherItems, ...reorderedItems].sort((a, b) => {
         const aGroup = parseInt(a.execution_group?.match(/\d+/)?.[0] || '999');
         const bGroup = parseInt(b.execution_group?.match(/\d+/)?.[0] || '999');
         if (aGroup !== bGroup) return aGroup - bGroup;
@@ -346,8 +395,14 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
         return (a.execution_order || 0) - (b.execution_order || 0);
       });
 
-      newQueue.forEach((item, idx) => { item.execution_order = idx + 1; delete item._idx; });
-      queue.tasks = newQueue;
+      newQueueItems.forEach((item, idx) => { item.execution_order = idx + 1; delete item._idx; });
+
+      // Write back to appropriate array based on queue type
+      if (isSolutionBased) {
+        queue.solutions = newQueueItems;
+      } else {
+        queue.tasks = newQueueItems;
+      }
       writeQueue(issuesDir, queue);
 
       return { success: true, groupId, reordered: newOrder.length };
@@ -376,6 +431,17 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
+  // GET /api/issues/history - List completed issues from history
+  if (pathname === '/api/issues/history' && req.method === 'GET') {
+    const history = readIssueHistoryJsonl(issuesDir);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      issues: history,
+      _metadata: { version: '1.0', storage: 'jsonl', total_issues: history.length, last_updated: new Date().toISOString() }
+    }));
+    return true;
+  }
+
   // POST /api/issues - Create issue
   if (pathname === '/api/issues' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
@@ -392,7 +458,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
         context: body.context || '',
         source: body.source || 'text',
         source_url: body.source_url || null,
-        labels: body.labels || [],
+        tags: body.tags || [],
         created_at: new Date().toISOString(),
         updated_at: new Date().toISOString()
       };
@@ -451,7 +517,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
       }
 
       // Update other fields
-      for (const field of ['title', 'context', 'status', 'priority', 'labels']) {
+      for (const field of ['title', 'context', 'status', 'priority', 'tags']) {
         if (body[field] !== undefined) {
           issues[issueIndex][field] = body[field];
           updates.push(field);
@@ -633,7 +699,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
       if (issueIndex === -1) return { error: 'Issue not found' };
 
       const updates: string[] = [];
-      for (const field of ['title', 'context', 'status', 'priority', 'bound_solution_id', 'labels']) {
+      for (const field of ['title', 'context', 'status', 'priority', 'bound_solution_id', 'tags']) {
         if (body[field] !== undefined) {
           issues[issueIndex][field] = body[field];
           updates.push(field);

package/ccw/src/tools/cli-executor.ts

@@ -10,6 +10,39 @@ import { spawn, ChildProcess } from 'child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync, statSync } from 'fs';
 import { join, relative } from 'path';
 
+// Debug logging utility - check env at runtime for --debug flag support
+function isDebugEnabled(): boolean {
+  return process.env.DEBUG === 'true' || process.env.DEBUG === '1' || process.env.CCW_DEBUG === 'true';
+}
+
+function debugLog(category: string, message: string, data?: Record<string, unknown>): void {
+  if (!isDebugEnabled()) return;
+  const timestamp = new Date().toISOString();
+  const prefix = `[${timestamp}] [CLI-DEBUG] [${category}]`;
+  if (data) {
+    console.error(`${prefix} ${message}`, JSON.stringify(data, null, 2));
+  } else {
+    console.error(`${prefix} ${message}`);
+  }
+}
+
+function errorLog(category: string, message: string, error?: Error | unknown, context?: Record<string, unknown>): void {
+  const timestamp = new Date().toISOString();
+  const prefix = `[${timestamp}] [CLI-ERROR] [${category}]`;
+  console.error(`${prefix} ${message}`);
+  if (error instanceof Error) {
+    console.error(`${prefix} Error: ${error.message}`);
+    if (isDebugEnabled() && error.stack) {
+      console.error(`${prefix} Stack: ${error.stack}`);
+    }
+  } else if (error) {
+    console.error(`${prefix} Error: ${String(error)}`);
+  }
+  if (context) {
+    console.error(`${prefix} Context:`, JSON.stringify(context, null, 2));
+  }
+}
+
 // LiteLLM integration
 import { executeLiteLLMEndpoint } from './litellm-executor.js';
 import { findEndpointById } from '../config/litellm-api-config-manager.js';
@@ -205,9 +238,12 @@ interface ExecutionOutput {
  * Check if a CLI tool is available (with caching)
  */
 async function checkToolAvailability(tool: string): Promise<ToolAvailability> {
+  debugLog('TOOL_CHECK', `Checking availability for tool: ${tool}`);
+
   // Check cache first
   const cached = toolAvailabilityCache.get(tool);
   if (cached && isCacheValid(cached)) {
+    debugLog('TOOL_CHECK', `Cache hit for ${tool}`, { available: cached.result.available, path: cached.result.path });
     return cached.result;
   }
 
@@ -219,6 +255,8 @@ async function checkToolAvailability(tool: string): Promise<ToolAvailability> {
     const isWindows = process.platform === 'win32';
     const command = isWindows ? 'where' : 'which';
 
+    debugLog('TOOL_CHECK', `Running ${command} ${tool}`, { platform: process.platform });
+
     // Direct spawn - where/which are system commands that don't need shell wrapper
     const child = spawn(command, [tool], {
       shell: false,
@@ -226,25 +264,31 @@ async function checkToolAvailability(tool: string): Promise<ToolAvailability> {
     });
 
     let stdout = '';
+    let stderr = '';
     child.stdout!.on('data', (data) => { stdout += data.toString(); });
+    child.stderr?.on('data', (data) => { stderr += data.toString(); });
 
     child.on('close', (code) => {
       const result: ToolAvailability = code === 0 && stdout.trim()
         ? { available: true, path: stdout.trim().split('\n')[0] }
         : { available: false, path: null };
 
-      // Only cache positive results to avoid caching transient failures
       if (result.available) {
+        debugLog('TOOL_CHECK', `Tool ${tool} found`, { path: result.path });
+        // Only cache positive results to avoid caching transient failures
         toolAvailabilityCache.set(tool, {
           result,
           timestamp: Date.now()
         });
+      } else {
+        debugLog('TOOL_CHECK', `Tool ${tool} not found`, { exitCode: code, stderr: stderr.trim() || '(empty)' });
       }
 
       resolve(result);
     });
 
-    child.on('error', () => {
+    child.on('error', (error) => {
+      errorLog('TOOL_CHECK', `Failed to check tool availability: ${tool}`, error, { command, tool });
       // Don't cache errors - they may be transient
       resolve({ available: false, path: null });
     });
@@ -252,6 +296,7 @@ async function checkToolAvailability(tool: string): Promise<ToolAvailability> {
     // Timeout after 5 seconds
     setTimeout(() => {
       child.kill();
+      debugLog('TOOL_CHECK', `Timeout checking tool ${tool} (5s)`);
       // Don't cache timeouts - they may be transient
       resolve({ available: false, path: null });
     }, 5000);
@@ -279,6 +324,15 @@ function buildCommand(params: {
 }): { command: string; args: string[]; useStdin: boolean } {
   const { tool, prompt, mode = 'analysis', model, dir, include, nativeResume } = params;
 
+  debugLog('BUILD_CMD', `Building command for tool: ${tool}`, {
+    mode,
+    model: model || '(default)',
+    dir: dir || '(cwd)',
+    include: include || '(none)',
+    nativeResume: nativeResume ? { enabled: nativeResume.enabled, isLatest: nativeResume.isLatest, sessionId: nativeResume.sessionId } : '(none)',
+    promptLength: prompt.length
+  });
+
   let command = tool;
   let args: string[] = [];
   // Default to stdin for all tools to avoid escaping issues on Windows
@@ -418,9 +472,17 @@ function buildCommand(params: {
       break;
 
     default:
+      errorLog('BUILD_CMD', `Unknown CLI tool: ${tool}`);
       throw new Error(`Unknown CLI tool: ${tool}`);
   }
 
+  debugLog('BUILD_CMD', `Command built successfully`, {
+    command,
+    args,
+    useStdin,
+    fullCommand: `${command} ${args.join(' ')}${useStdin ? ' (stdin)' : ''}`
+  });
+
   return { command, args, useStdin };
 }
 
@@ -596,7 +658,7 @@ async function executeCliTool(
   ensureHistoryDir(workingDir); // Ensure history directory exists
 
   // NEW: Check if model is a custom LiteLLM endpoint ID
-  if (model && !['gemini', 'qwen', 'codex'].includes(tool)) {
+  if (model) {
     const endpoint = findEndpointById(workingDir, model);
     if (endpoint) {
       // Route to LiteLLM executor
@@ -821,18 +883,42 @@ async function executeCliTool(
 
   const startTime = Date.now();
 
+  debugLog('EXEC', `Starting CLI execution`, {
+    tool,
+    mode,
+    workingDir,
+    conversationId,
+    promptLength: finalPrompt.length,
+    hasResume: !!resume,
+    hasCustomId: !!customId
+  });
+
   return new Promise((resolve, reject) => {
     // Windows requires shell: true for npm global commands (.cmd files)
     // Unix-like systems can use shell: false for direct execution
     const isWindows = process.platform === 'win32';
+
+    debugLog('SPAWN', `Spawning process`, {
+      command,
+      args,
+      cwd: workingDir,
+      shell: isWindows,
+      useStdin,
+      platform: process.platform,
+      fullCommand: `${command} ${args.join(' ')}`
+    });
+
     const child = spawn(command, args, {
       cwd: workingDir,
       shell: isWindows,  // Enable shell on Windows for .cmd files
       stdio: [useStdin ? 'pipe' : 'ignore', 'pipe', 'pipe']
     });
 
+    debugLog('SPAWN', `Process spawned`, { pid: child.pid });
+
     // Write prompt to stdin if using stdin mode (for gemini/qwen)
     if (useStdin && child.stdin) {
+      debugLog('STDIN', `Writing prompt to stdin (${finalPrompt.length} bytes)`);
       child.stdin.write(finalPrompt);
       child.stdin.end();
     }
@@ -864,10 +950,19 @@ async function executeCliTool(
       const endTime = Date.now();
       const duration = endTime - startTime;
 
+      debugLog('CLOSE', `Process closed`, {
+        exitCode: code,
+        duration: `${duration}ms`,
+        timedOut,
+        stdoutLength: stdout.length,
+        stderrLength: stderr.length
+      });
+
       // Determine status - prioritize output content over exit code
       let status: 'success' | 'error' | 'timeout' = 'success';
       if (timedOut) {
         status = 'timeout';
+        debugLog('STATUS', `Execution timed out after ${duration}ms`);
       } else if (code !== 0) {
         // Non-zero exit code doesn't always mean failure
         // Check if there's valid output (AI response) - treat as success
@@ -877,12 +972,31 @@ async function executeCliTool(
                               stderr.includes('API key') ||
                               stderr.includes('rate limit exceeded');
 
+        debugLog('STATUS', `Non-zero exit code analysis`, {
+          exitCode: code,
+          hasValidOutput,
+          hasFatalError,
+          stderrPreview: stderr.substring(0, 500)
+        });
+
         if (hasValidOutput && !hasFatalError) {
           // Has output and no fatal errors - treat as success despite exit code
           status = 'success';
+          debugLog('STATUS', `Treating as success (has valid output, no fatal errors)`);
         } else {
           status = 'error';
+          errorLog('EXEC', `CLI execution failed`, undefined, {
+            exitCode: code,
+            tool,
+            command,
+            args,
+            workingDir,
+            stderrFull: stderr,
+            stdoutPreview: stdout.substring(0, 200)
+          });
         }
+      } else {
+        debugLog('STATUS', `Execution successful (exit code 0)`);
       }
 
       // Create new turn - cache full output when not streaming (default)
@@ -1066,7 +1180,16 @@ async function executeCliTool(
 
     // Handle errors
     child.on('error', (error) => {
-      reject(new Error(`Failed to spawn ${tool}: ${error.message}`));
+      errorLog('SPAWN', `Failed to spawn process`, error, {
+        tool,
+        command,
+        args,
+        workingDir,
+        fullCommand: `${command} ${args.join(' ')}`,
+        platform: process.platform,
+        path: process.env.PATH?.split(process.platform === 'win32' ? ';' : ':').slice(0, 10).join('\n  ') + '...'
+      });
+      reject(new Error(`Failed to spawn ${tool}: ${error.message}\n  Command: ${command} ${args.join(' ')}\n  Working Dir: ${workingDir}`));
     });
 
     // Timeout handling (timeout=0 disables internal timeout, controlled by external caller)

package/ccw/src/tools/litellm-executor.ts

@@ -11,15 +11,19 @@ import {
 } from '../config/litellm-api-config-manager.js';
 import type { CustomEndpoint, ProviderCredential } from '../types/litellm-api-config.js';
 
-export interface LiteLLMExecutionOptions {
-  prompt: string;
-  endpointId: string; // Custom endpoint ID (e.g., "my-gpt4o")
-  baseDir: string; // Project base directory
-  cwd?: string; // Working directory for file resolution
-  includeDirs?: string[]; // Additional directories for @patterns
-  enableCache?: boolean; // Override endpoint cache setting
-  onOutput?: (data: { type: string; data: string }) => void;
-}
+export interface LiteLLMExecutionOptions {
+  prompt: string;
+  endpointId: string; // Custom endpoint ID (e.g., "my-gpt4o")
+  baseDir: string; // Project base directory
+  cwd?: string; // Working directory for file resolution
+  includeDirs?: string[]; // Additional directories for @patterns
+  enableCache?: boolean; // Override endpoint cache setting
+  onOutput?: (data: { type: string; data: string }) => void;
+  /** Number of retries after the initial attempt (default: 0) */
+  maxRetries?: number;
+  /** Base delay for exponential backoff in milliseconds (default: 1000) */
+  retryBaseDelayMs?: number;
+}
 
 export interface LiteLLMExecutionResult {
   success: boolean;
@@ -48,10 +52,10 @@ export function extractPatterns(prompt: string): string[] {
 /**
  * Execute LiteLLM endpoint with optional context caching
  */
-export async function executeLiteLLMEndpoint(
-  options: LiteLLMExecutionOptions
-): Promise<LiteLLMExecutionResult> {
-  const { prompt, endpointId, baseDir, cwd, includeDirs, enableCache, onOutput } = options;
+export async function executeLiteLLMEndpoint(
+  options: LiteLLMExecutionOptions
+): Promise<LiteLLMExecutionResult> {
+  const { prompt, endpointId, baseDir, cwd, includeDirs, enableCache, onOutput } = options;
 
   // 1. Find endpoint configuration
   const endpoint = findEndpointById(baseDir, endpointId);
@@ -179,8 +183,16 @@ export async function executeLiteLLMEndpoint(
       }
     }
 
-    // Use litellm-client to call chat
-    const response = await client.chat(finalPrompt, endpoint.model);
+    // Use litellm-client to call chat
+    const response = await callWithRetries(
+      () => client.chat(finalPrompt, endpoint.model),
+      {
+        maxRetries: options.maxRetries ?? 0,
+        baseDelayMs: options.retryBaseDelayMs ?? 1000,
+        onOutput,
+        rateLimitKey: `${provider.type}:${endpoint.model}`,
+      },
+    );
 
     if (onOutput) {
       onOutput({ type: 'stdout', data: response });
@@ -230,12 +242,83 @@ function getProviderEnvVarName(providerType: string): string | null {
 /**
  * Get environment variable name for provider base URL
  */
-function getProviderBaseUrlEnvVarName(providerType: string): string | null {
-  const envVarMap: Record<string, string> = {
-    openai: 'OPENAI_API_BASE',
-    anthropic: 'ANTHROPIC_API_BASE',
-    azure: 'AZURE_API_BASE',
-  };
-
-  return envVarMap[providerType] || null;
-}
+function getProviderBaseUrlEnvVarName(providerType: string): string | null {
+  const envVarMap: Record<string, string> = {
+    openai: 'OPENAI_API_BASE',
+    anthropic: 'ANTHROPIC_API_BASE',
+    azure: 'AZURE_API_BASE',
+  };
+
+  return envVarMap[providerType] || null;
+}
+
+const rateLimitRetryQueueNextAt = new Map<string, number>();
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isRateLimitError(errorMessage: string): boolean {
+  return /429|rate limit|too many requests/i.test(errorMessage);
+}
+
+function isRetryableError(errorMessage: string): boolean {
+  // Never retry auth/config errors
+  if (/401|403|unauthorized|forbidden/i.test(errorMessage)) {
+    return false;
+  }
+
+  // Retry rate limits, transient server errors, and network timeouts
+  return /(429|500|502|503|504|timeout|timed out|econnreset|enotfound|econnrefused|socket hang up)/i.test(
+    errorMessage,
+  );
+}
+
+async function callWithRetries(
+  call: () => Promise<string>,
+  options: {
+    maxRetries: number;
+    baseDelayMs: number;
+    onOutput?: (data: { type: string; data: string }) => void;
+    rateLimitKey: string;
+  },
+): Promise<string> {
+  const { maxRetries, baseDelayMs, onOutput, rateLimitKey } = options;
+  let attempt = 0;
+
+  while (true) {
+    try {
+      return await call();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+
+      if (attempt >= maxRetries || !isRetryableError(errorMessage)) {
+        throw err;
+      }
+
+      const delayMs = baseDelayMs * 2 ** attempt;
+
+      if (onOutput) {
+        onOutput({
+          type: 'stderr',
+          data: `[LiteLLM retry ${attempt + 1}/${maxRetries}: waiting ${delayMs}ms] ${errorMessage}\n`,
+        });
+      }
+
+      attempt += 1;
+
+      if (isRateLimitError(errorMessage)) {
+        const now = Date.now();
+        const earliestAt = now + delayMs;
+        const queuedAt = rateLimitRetryQueueNextAt.get(rateLimitKey) ?? 0;
+        const scheduledAt = Math.max(queuedAt, earliestAt);
+        rateLimitRetryQueueNextAt.set(rateLimitKey, scheduledAt + delayMs);
+
+        await sleep(scheduledAt - now);
+        continue;
+      }
+
+      await sleep(delayMs);
+    }
+  }
+}