@parallel-cli/parallel 0.4.9 → 0.5.0

package/dist/diagnostics.js

@@ -0,0 +1,209 @@
+export const SIMPLE_DIAGNOSTIC_BUDGETS = {
+    maxRounds: 6,
+    maxToolCalls: 12,
+    maxShellCommands: 2,
+    maxRepeatedReads: 1,
+    maxRepeatedCommands: 1,
+    maxInputTokens: 150_000,
+    maxContextAmplification: 12,
+};
+function textSize(value) {
+    if (typeof value === 'string')
+        return value.length;
+    if (value === null || value === undefined)
+        return 0;
+    return JSON.stringify(value).length;
+}
+function parseArgs(raw) {
+    try {
+        const parsed = JSON.parse(raw || '{}');
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function counts(values) {
+    const map = new Map();
+    for (const value of values)
+        map.set(value, (map.get(value) ?? 0) + 1);
+    return [...map.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([value, count]) => ({ value, count }))
+        .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
+}
+export function analyzeAgentConversation(messages, observed = {}) {
+    const budgets = { ...SIMPLE_DIAGNOSTIC_BUDGETS, ...(observed.budgets ?? {}) };
+    const toolCounts = {};
+    const commands = [];
+    const reads = [];
+    let assistantRounds = 0;
+    let toolCalls = 0;
+    let updateOnlyRounds = 0;
+    let totalToolResultChars = 0;
+    let largestToolResultChars = 0;
+    let approximateContextCharsSent = 0;
+    let cumulativeChars = 0;
+    let virtualHistoryMessages = 0;
+    let estimatedCompactionCalls = 0;
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        virtualHistoryMessages++;
+        if (message.role === 'assistant') {
+            assistantRounds++;
+            approximateContextCharsSent += cumulativeChars;
+            const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+            const names = calls.map((call) => String(call.function?.name ?? 'unknown'));
+            if (names.length > 0 && names.every((name) => name === 'update_status' || name === 'update_steps')) {
+                updateOnlyRounds++;
+            }
+            for (const call of calls) {
+                const name = String(call.function?.name ?? 'unknown');
+                const args = parseArgs(call.function?.arguments);
+                toolCalls++;
+                toolCounts[name] = (toolCounts[name] ?? 0) + 1;
+                if (name === 'run_command')
+                    commands.push(String(args.command ?? '').trim().replace(/\s+/g, ' '));
+                if (name === 'read_file')
+                    reads.push(String(args.path ?? '').trim());
+                if (name === 'read_many' && Array.isArray(args.paths))
+                    reads.push(...args.paths.map(String));
+            }
+        }
+        if (message.role === 'tool') {
+            const size = textSize(message.content);
+            totalToolResultChars += size;
+            largestToolResultChars = Math.max(largestToolResultChars, size);
+        }
+        cumulativeChars += textSize(message.content) + textSize(message.tool_calls) + 20;
+        const next = messages[index + 1];
+        const endsToolRound = message.role === 'tool' && next?.role !== 'tool';
+        if (endsToolRound && virtualHistoryMessages > 80) {
+            estimatedCompactionCalls++;
+            virtualHistoryMessages = 42;
+        }
+    }
+    const transcriptChars = Math.max(1, cumulativeChars);
+    const repeatedCommands = counts(commands.filter(Boolean)).map(({ value, count }) => ({ command: value, count }));
+    const repeatedReads = counts(reads.filter(Boolean)).map(({ value, count }) => ({ path: value, count }));
+    const shellCommands = toolCounts.run_command ?? 0;
+    const readOnlyShellCommands = observed.perf?.readOnlyShellCommands ?? shellCommands;
+    const contextAmplification = approximateContextCharsSent / transcriptChars;
+    const findings = [];
+    if (assistantRounds > budgets.maxRounds) {
+        findings.push({
+            severity: assistantRounds > budgets.maxRounds * 2 ? 'critical' : 'warn',
+            code: 'too-many-model-rounds',
+            message: `${assistantRounds} sequential model rounds exceed the simple-task budget of ${budgets.maxRounds}.`,
+        });
+    }
+    if (toolCalls > budgets.maxToolCalls) {
+        findings.push({
+            severity: toolCalls > budgets.maxToolCalls * 2 ? 'critical' : 'warn',
+            code: 'tool-churn',
+            message: `${toolCalls} tool calls exceed the budget of ${budgets.maxToolCalls}.`,
+        });
+    }
+    if (shellCommands > budgets.maxShellCommands) {
+        findings.push({
+            severity: 'critical',
+            code: 'shell-micro-command-loop',
+            message: `${shellCommands} shell commands were used; batch inspection tools should keep this below ${budgets.maxShellCommands}.`,
+        });
+    }
+    if (repeatedReads.some((item) => item.count > budgets.maxRepeatedReads + 1)) {
+        findings.push({
+            severity: 'warn',
+            code: 'repeated-file-reads',
+            message: `Files were repeatedly re-read: ${repeatedReads.slice(0, 4).map((item) => `${item.path}×${item.count}`).join(', ')}.`,
+        });
+    }
+    if (repeatedCommands.some((item) => item.count > budgets.maxRepeatedCommands + 1)) {
+        findings.push({
+            severity: 'warn',
+            code: 'repeated-shell-commands',
+            message: `Shell commands were repeated: ${repeatedCommands.slice(0, 3).map((item) => `${item.command}×${item.count}`).join(', ')}.`,
+        });
+    }
+    if ((observed.inputTokens ?? 0) > budgets.maxInputTokens) {
+        findings.push({
+            severity: 'critical',
+            code: 'prompt-token-amplification',
+            message: `${observed.inputTokens?.toLocaleString()} cumulative input tokens exceed the simple-task budget of ${budgets.maxInputTokens.toLocaleString()}.`,
+        });
+    }
+    if (contextAmplification > budgets.maxContextAmplification) {
+        findings.push({
+            severity: 'critical',
+            code: 'full-history-resend',
+            message: `Approximate context amplification is ${contextAmplification.toFixed(1)}× because prior tool output is resent on every model turn.`,
+        });
+    }
+    if (largestToolResultChars > 10_000) {
+        findings.push({
+            severity: 'warn',
+            code: 'large-tool-result',
+            message: `The largest tool result was ${largestToolResultChars.toLocaleString()} characters and remained in later prompts.`,
+        });
+    }
+    const compactionCalls = Math.max(observed.perf?.compactionTurns ?? 0, estimatedCompactionCalls);
+    if (compactionCalls > 0) {
+        findings.push({
+            severity: 'warn',
+            code: 'hidden-compaction-calls',
+            message: `Approximately ${compactionCalls} extra model call(s) were spent compacting history outside the visible step count.`,
+        });
+    }
+    if (updateOnlyRounds > 1) {
+        findings.push({
+            severity: 'info',
+            code: 'coordination-only-rounds',
+            message: `${updateOnlyRounds} model rounds only updated status/steps without inspecting or completing work.`,
+        });
+    }
+    return {
+        messages: messages.length,
+        assistantRounds,
+        toolCalls,
+        toolCounts,
+        shellCommands,
+        readOnlyShellCommands,
+        repeatedCommands,
+        repeatedReads,
+        inspectProjectCalls: toolCounts.inspect_project ?? 0,
+        readManyCalls: toolCounts.read_many ?? 0,
+        updateOnlyRounds,
+        estimatedCompactionCalls,
+        totalToolResultChars,
+        largestToolResultChars,
+        approximateContextCharsSent,
+        transcriptChars,
+        contextAmplification,
+        inputTokens: observed.inputTokens,
+        outputTokens: observed.outputTokens,
+        elapsedMs: observed.elapsedMs,
+        perf: observed.perf,
+        findings,
+        withinBudget: !findings.some((finding) => finding.severity === 'critical'),
+    };
+}
+export function formatAgentDiagnostic(report) {
+    const lines = [
+        'Agent performance diagnostic',
+        `  rounds: ${report.assistantRounds}`,
+        `  tools: ${report.toolCalls} (${Object.entries(report.toolCounts).map(([name, count]) => `${name}=${count}`).join(', ')})`,
+        `  shell: ${report.shellCommands}`,
+        `  tool output: ${report.totalToolResultChars.toLocaleString()} chars, max ${report.largestToolResultChars.toLocaleString()}`,
+        `  context amplification: ${report.contextAmplification.toFixed(1)}×`,
+        `  estimated hidden compactions: ${report.estimatedCompactionCalls}`,
+    ];
+    if (report.inputTokens !== undefined)
+        lines.push(`  input tokens: ${report.inputTokens.toLocaleString()}`);
+    if (report.elapsedMs !== undefined)
+        lines.push(`  elapsed: ${(report.elapsedMs / 1000).toFixed(1)}s`);
+    lines.push(`  budget: ${report.withinBudget ? 'PASS' : 'FAIL'}`);
+    for (const finding of report.findings) {
+        lines.push(`  [${finding.severity.toUpperCase()}] ${finding.code}: ${finding.message}`);
+    }
+    return lines.join('\n');
+}

package/dist/i18n.js

@@ -87,6 +87,10 @@ const en = {
     'agent.compactingStart': 'Long memory: summarizing earlier history to keep useful context.',
     'agent.compactingDone': 'Long memory: earlier history summarized and kept in context.',
     'agent.compactingFallback': 'Long memory: earlier history was shortened to keep context responsive.',
+    'memory.indexing': 'Project memory: indexing the codebase…',
+    'memory.ready': 'Project memory ready.',
+    'memory.fallback': 'Project memory fallback: deterministic context. {detail}',
+    'memory.label': 'Memory',
     // input
     'input.atHint': ' — send a real-time instruction',
     'input.atAll': ' to all agents',
@@ -146,6 +150,7 @@ const en = {
     'cmd.notes': 'Inter-agent notes history',
     'cmd.diff': 'Live file diffs',
     'cmd.status': 'Show session status: model, agents, changes, cost',
+    'cmd.memory': 'Show or refresh the shared project memory',
     'cmd.raw': 'Toggle raw activity detail in focus view',
     'cmd.copy': 'Copy the latest completed agent result',
     'timeline.activity': 'Activity',
@@ -272,7 +277,10 @@ const en = {
     'm.cleared': 'Finished agents removed from display.',
     'm.clearedN': 'Removed {n} finished agent(s) from display.',
     'm.clearedNone': 'No finished agents to clear.',
-    'm.status': 'Status\n  Model  {pm}\n  Approvals  {approval}\n  Agents  {total} total / {active} active\n  Changed files  {changed}\n  Session cost  ${cost}',
+    'm.status': 'Status\n  Model  {pm}\n  Approvals  {approval}\n  Agents  {total} total / {active} active\n  Changed files  {changed}\n  Session cost  ${cost}\n  Project memory  {memory} / ${memoryCost}',
+    'm.usageMemory': 'Usage: /memory or /memory refresh',
+    'm.memoryStatus': 'Project memory\n  Status  {status}\n  Generated  {date}\n  Model  {model}\n  Tokens  {tokens}\n  Cost  ${cost}',
+    'm.doctorMemory': '• Project memory: {status} (generated {date})',
     'm.rawOn': 'Raw activity detail ON — raw agent logs visible in focus view.',
     'm.rawOff': 'Raw activity detail OFF.',
     'm.copyNone': 'No completed agent output to copy.',
@@ -345,6 +353,7 @@ const en = {
     'q.keys': '↑/↓ + Enter or 1-4 to answer · no answer in 30s → the recommended option is chosen',
     // cost view
     'cost.title': '💰 SESSION COST — real time, per agent',
+    'cost.memory': 'Project memory',
     'cost.empty': 'No agents yet — costs will appear here in real time.',
     'cost.unknown': '(unknown price — set it in /settings → Model prices)',
     'cost.total': 'Session total:',
@@ -488,6 +497,10 @@ const fr = {
     'agent.compactingStart': "Mémoire longue : résumé automatique de l'historique pour garder le contexte utile.",
     'agent.compactingDone': "Mémoire longue : l'historique ancien est résumé et conservé dans le contexte.",
     'agent.compactingFallback': "Mémoire longue : l'historique ancien a été raccourci pour garder le contexte réactif.",
+    'memory.indexing': 'Mémoire projet : indexation du codebase…',
+    'memory.ready': 'Mémoire projet prête.',
+    'memory.fallback': 'Mémoire projet en fallback : contexte déterministe. {detail}',
+    'memory.label': 'Mémoire',
     'input.atHint': ' — envoyer une instruction temps réel',
     'input.atAll': ' à tous les agents',
     'input.pasted': '[collé #{n} : {lines} lignes]',
@@ -543,6 +556,7 @@ const fr = {
     'cmd.notes': 'Historique des notes inter-agents',
     'cmd.diff': 'Modifications de fichiers (diffs en direct)',
     'cmd.status': 'Afficher le statut de la session : modèle, agents, changements, coût',
+    'cmd.memory': 'Afficher ou régénérer la mémoire projet partagée',
     'cmd.raw': 'Basculer le détail brut de l\'activité dans la vue focus',
     'cmd.copy': 'Copier le dernier résultat d\'agent terminé',
     'timeline.activity': 'Activité',
@@ -668,7 +682,10 @@ const fr = {
     'm.cleared': "Agents terminés retirés de l'affichage.",
     'm.clearedN': "{n} agent(s) terminé(s) retiré(s) de l'affichage.",
     'm.clearedNone': "Aucun agent terminé à retirer.",
-    'm.status': "Statut\n  Modèle  {pm}\n  Approbations  {approval}\n  Agents  {total} total / {active} actif(s)\n  Fichiers modifiés  {changed}\n  Coût session  ${cost}",
+    'm.status': "Statut\n  Modèle  {pm}\n  Approbations  {approval}\n  Agents  {total} total / {active} actif(s)\n  Fichiers modifiés  {changed}\n  Coût session  ${cost}\n  Mémoire projet  {memory} / ${memoryCost}",
+    'm.usageMemory': 'Usage : /memory ou /memory refresh',
+    'm.memoryStatus': 'Mémoire projet\n  Statut  {status}\n  Générée  {date}\n  Modèle  {model}\n  Tokens  {tokens}\n  Coût  ${cost}',
+    'm.doctorMemory': '• Mémoire projet : {status} (générée {date})',
     'm.rawOn': 'Détail brut activé — logs agents visibles dans la vue focus.',
     'm.rawOff': 'Détail brut désactivé.',
     'm.copyNone': "Aucun résultat d'agent à copier.",
@@ -738,6 +755,7 @@ const fr = {
     'q.recommended': '★ recommandé',
     'q.keys': '↑/↓ + Entrée ou 1-4 pour répondre · sans réponse en 30s → l’option recommandée est choisie',
     'cost.title': '💰 COÛT DE LA SESSION — temps réel, par agent',
+    'cost.memory': 'Mémoire projet',
     'cost.empty': 'Aucun agent pour le moment — les coûts apparaîtront ici en temps réel.',
     'cost.unknown': '(prix inconnu — règle-le dans /settings → Prix des modèles)',
     'cost.total': 'Total session :',
@@ -877,6 +895,10 @@ const es = {
     'agent.compactingStart': 'Memoria larga: resumen automático del historial para conservar el contexto útil.',
     'agent.compactingDone': 'Memoria larga: el historial anterior se resumió y se mantuvo en contexto.',
     'agent.compactingFallback': 'Memoria larga: el historial anterior se acortó para mantener el contexto ágil.',
+    'memory.indexing': 'Memoria del proyecto: indexando el código…',
+    'memory.ready': 'Memoria del proyecto lista.',
+    'memory.fallback': 'Memoria del proyecto en modo fallback: contexto determinista. {detail}',
+    'memory.label': 'Memoria',
     'input.atHint': ' — enviar una instrucción en tiempo real',
     'input.atAll': ' a todos los agentes',
     'input.pasted': '[pegado #{n}: {lines} líneas]',
@@ -932,6 +954,7 @@ const es = {
     'cmd.notes': 'Historial de notas entre agentes',
     'cmd.diff': 'Diffs de archivos en vivo',
     'cmd.status': 'Mostrar estado de la sesión: modelo, agentes, cambios, coste',
+    'cmd.memory': 'Mostrar o actualizar la memoria compartida del proyecto',
     'cmd.raw': 'Alternar detalle de actividad sin procesar en la vista focus',
     'cmd.copy': 'Copiar el último resultado de agente completado',
     'timeline.activity': 'Actividad',
@@ -1057,7 +1080,10 @@ const es = {
     'm.cleared': 'Agentes terminados quitados de la pantalla.',
     'm.clearedN': '{n} agente(s) terminado(s) quitado(s) de la pantalla.',
     'm.clearedNone': 'No hay agentes terminados que quitar.',
-    'm.status': 'Estado\n  Modelo  {pm}\n  Aprobaciones  {approval}\n  Agentes  {total} total / {active} activo(s)\n  Archivos cambiados  {changed}\n  Coste sesión  ${cost}',
+    'm.status': 'Estado\n  Modelo  {pm}\n  Aprobaciones  {approval}\n  Agentes  {total} total / {active} activo(s)\n  Archivos cambiados  {changed}\n  Coste sesión  ${cost}\n  Memoria del proyecto  {memory} / ${memoryCost}',
+    'm.usageMemory': 'Uso: /memory o /memory refresh',
+    'm.memoryStatus': 'Memoria del proyecto\n  Estado  {status}\n  Generada  {date}\n  Modelo  {model}\n  Tokens  {tokens}\n  Coste  ${cost}',
+    'm.doctorMemory': '• Memoria del proyecto: {status} (generada {date})',
     'm.rawOn': 'Detalle de actividad activado — logs visibles en vista focus.',
     'm.rawOff': 'Detalle de actividad desactivado.',
     'm.copyNone': 'No hay resultado de agente que copiar.',
@@ -1127,6 +1153,7 @@ const es = {
     'q.recommended': '★ recomendado',
     'q.keys': '↑/↓ + Enter o 1-4 para responder · sin respuesta en 30s → se elige la opción recomendada',
     'cost.title': '💰 COSTE DE LA SESIÓN — tiempo real, por agente',
+    'cost.memory': 'Memoria del proyecto',
     'cost.empty': 'Aún no hay agentes — los costes aparecerán aquí en tiempo real.',
     'cost.unknown': '(precio desconocido — defínelo en /settings → Precios de modelos)',
     'cost.total': 'Total de la sesión:',
@@ -1266,6 +1293,10 @@ const zh = {
     'agent.compactingStart': '长记忆：正在自动总结较早历史，以保留有用上下文。',
     'agent.compactingDone': '长记忆：较早历史已总结并保留在上下文中。',
     'agent.compactingFallback': '长记忆：较早历史已缩短，以保持上下文响应速度。',
+    'memory.indexing': '项目记忆：正在索引代码库…',
+    'memory.ready': '项目记忆已就绪。',
+    'memory.fallback': '项目记忆使用确定性回退上下文。{detail}',
+    'memory.label': '记忆',
     'input.atHint': ' — 发送实时指令',
     'input.atAll': ' 给所有智能体',
     'input.pasted': '[粘贴 #{n}：{lines} 行]',
@@ -1321,6 +1352,7 @@ const zh = {
     'cmd.notes': '智能体间便签历史',
     'cmd.diff': '实时文件差异',
     'cmd.status': '显示会话状态：模型、智能体、更改、费用',
+    'cmd.memory': '显示或刷新共享项目记忆',
     'cmd.raw': '在焦点视图中切换原始活动详情',
     'cmd.copy': '复制最新完成的智能体结果',
     'timeline.activity': '活动',
@@ -1446,7 +1478,10 @@ const zh = {
     'm.cleared': '已从显示中移除完成的智能体。',
     'm.clearedN': '已从显示中移除 {n} 个完成的智能体。',
     'm.clearedNone': '没有可移除的已完成智能体。',
-    'm.status': '状态\n  模型  {pm}\n  批准  {approval}\n  智能体  {total} 个总计 / {active} 个活跃\n  已更改文件  {changed}\n  会话费用  ${cost}',
+    'm.status': '状态\n  模型  {pm}\n  批准  {approval}\n  智能体  {total} 个总计 / {active} 个活跃\n  已更改文件  {changed}\n  会话费用  ${cost}\n  项目记忆  {memory} / ${memoryCost}',
+    'm.usageMemory': '用法：/memory 或 /memory refresh',
+    'm.memoryStatus': '项目记忆\n  状态  {status}\n  生成时间  {date}\n  模型  {model}\n  Tokens  {tokens}\n  费用  ${cost}',
+    'm.doctorMemory': '• 项目记忆：{status}（生成于 {date}）',
     'm.rawOn': '原始活动详情已开启 — 焦点视图中可查看原始智能体日志。',
     'm.rawOff': '原始活动详情已关闭。',
     'm.copyNone': '没有可复制的已完成智能体输出。',
@@ -1516,6 +1551,7 @@ const zh = {
     'q.recommended': '★ 推荐',
     'q.keys': '↑/↓ + 回车 或 1-4 回答 · 30 秒内未回答 → 自动选择推荐选项',
     'cost.title': '💰 会话成本 — 实时，按智能体',
+    'cost.memory': '项目记忆',
     'cost.empty': '尚无智能体 — 成本将在此实时显示。',
     'cost.unknown': '（价格未知 — 在 /settings → 模型价格 中设置）',
     'cost.total': '会话总计：',

package/dist/index.js

@@ -34,6 +34,15 @@ const noUpdate = argv.includes('--no-update');
 if (noUpdate)
     argv.splice(argv.indexOf('--no-update'), 1);
 const configHome = takeFlagValue('--config-home');
+let forcedProfile;
+for (const candidate of ['quick', 'standard', 'deep']) {
+    const flag = `--${candidate}`;
+    if (argv.includes(flag)) {
+        forcedProfile = candidate;
+        argv.splice(argv.indexOf(flag), 1);
+        break;
+    }
+}
 if (argv.includes('--help') || argv.includes('-h')) {
     console.log(`⚡ Parallel — real-time parallel coding agents.
 
@@ -48,7 +57,7 @@ Usage:
                           Use <dir>/config.json instead of ~/.parallel/config.json
   parallel --no-update [folder]
                           Start without checking npm for a newer Parallel version
-  parallel --headless "task1" ["task2"…] [--json]
+  parallel --headless "task1" ["task2"…] [--quick|--standard|--deep] [--json]
                           No TUI: one agent per task in the current folder,
                           auto-safe shell, summary (or JSON) on stdout — for CI
   parallel --headless --yolo "task"
@@ -139,7 +148,7 @@ if (headless) {
             ctl.answerQuestion(q.id, q.options[q.recommended] ?? '', true);
     });
     for (const task of tasks) {
-        if (!ctl.spawnAgent(task)) {
+        if (!ctl.spawnAgent(task, undefined, undefined, undefined, undefined, undefined, 'task', forcedProfile)) {
             console.error(`Failed to spawn an agent for: ${task}`);
             process.exit(1);
         }
@@ -170,6 +179,7 @@ if (headless) {
         alias: a.alias,
         task: a.task,
         state: a.state,
+        profile: a.profile,
         steps: a.steps,
         tokensIn: a.tokensIn,
         tokensOut: a.tokensOut,

package/dist/llm/client.js

@@ -10,8 +10,9 @@ export class LLMClient {
      * One chat completion round, with optional function-calling tools.
      * Retries on transient errors (429/5xx) with exponential backoff.
      */
-    async chat(messages, tools, signal) {
+    async chat(messages, tools, signal, options = {}) {
         let lastErr;
+        let retries = 0;
         for (let attempt = 0; attempt < 4; attempt++) {
             try {
                 const res = await this.client.chat.completions.create({
@@ -19,8 +20,8 @@ export class LLMClient {
                     messages,
                     tools: tools && tools.length > 0 ? tools : undefined,
                     temperature: 0.2,
-                    max_tokens: 4096,
-                }, { signal });
+                    max_tokens: options.maxTokens ?? 4096,
+                }, { signal, timeout: options.timeoutMs });
                 const choice = res.choices[0];
                 if (!choice?.message)
                     throw new Error('Empty response from model');
@@ -28,6 +29,8 @@ export class LLMClient {
                     message: choice.message,
                     tokensIn: res.usage?.prompt_tokens ?? 0,
                     tokensOut: res.usage?.completion_tokens ?? 0,
+                    cachedTokens: Number(res.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+                    retries,
                 };
             }
             catch (err) {
@@ -38,6 +41,7 @@ export class LLMClient {
                 const retriable = status === 429 || (typeof status === 'number' && status >= 500) || err?.code === 'ECONNRESET';
                 if (!retriable || attempt === 3)
                     throw err;
+                retries++;
                 await new Promise((r) => setTimeout(r, 1500 * Math.pow(2, attempt)));
             }
         }