agentic-qe 3.14.8 → 3.15.0

package/dist/shared/git/git-analyzer.js

@@ -66,10 +66,11 @@ export class GitAnalyzer {
             return 0.4; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
-            // Use execFileSync with argument array to prevent injection
+            const relativePath = this.getRelativePath(filePath);
+            // Literal pathspecs preserve route filenames such as app/[id].tsx.
+            // execFileSync passes arguments directly without shell interpretation.
             const output = execFileSync('git', [
-                'log', '--oneline', '--since=90 days ago', '--', relativePath
+                '--literal-pathspecs', 'log', '--oneline', '--since=90 days ago', '--', relativePath
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
@@ -97,10 +98,10 @@ export class GitAnalyzer {
             return 0.5; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Get blame info using execFileSync with argument array
             const blameOutput = execFileSync('git', [
-                'blame', '--line-porcelain', '--', relativePath
+                '--literal-pathspecs', 'blame', '--line-porcelain', '--', relativePath
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
@@ -143,12 +144,12 @@ export class GitAnalyzer {
             return 0.4; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Get first commit date using execFileSync with argument array
             let firstCommitTimestamp = NaN;
             try {
                 const firstCommitOutput = execFileSync('git', [
-                    'log', '--format=%at', '--follow', '--diff-filter=A', '--', relativePath
+                    '--literal-pathspecs', 'log', '--format=%at', '--follow', '--diff-filter=A', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -167,7 +168,7 @@ export class GitAnalyzer {
             let lastCommitTimestamp = NaN;
             try {
                 const lastCommitOutput = execFileSync('git', [
-                    'log', '-1', '--format=%at', '--', relativePath
+                    '--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -216,7 +217,7 @@ export class GitAnalyzer {
             return 0.2; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Search for each keyword separately and count unique commits
             // This avoids shell injection from keywords config
             let bugCommits = 0;
@@ -225,7 +226,7 @@ export class GitAnalyzer {
                 const sanitizedKeyword = sanitizeGitArg(keyword);
                 try {
                     const output = execFileSync('git', [
-                        'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
+                        '--literal-pathspecs', 'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
                     ], {
                         cwd: this.config.repoRoot,
                         encoding: 'utf-8',
@@ -267,12 +268,12 @@ export class GitAnalyzer {
             return this.getDefaultFileHistory(filePath);
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Get commit count using execFileSync with argument array
             let totalCommits = 0;
             try {
                 const commitCountOutput = execFileSync('git', [
-                    'log', '--oneline', '--', relativePath
+                    '--literal-pathspecs', 'log', '--oneline', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -287,7 +288,7 @@ export class GitAnalyzer {
             let uniqueAuthors = 0;
             try {
                 const authorsOutput = execFileSync('git', [
-                    'log', '--format=%ae', '--', relativePath
+                    '--literal-pathspecs', 'log', '--format=%ae', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -305,7 +306,7 @@ export class GitAnalyzer {
             let firstCommit = null;
             try {
                 const firstCommitOutput = execFileSync('git', [
-                    'log', '--format=%at', '--follow', '--', relativePath
+                    '--literal-pathspecs', 'log', '--format=%at', '--follow', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -328,7 +329,7 @@ export class GitAnalyzer {
             let lastCommit = null;
             try {
                 const lastCommitOutput = execFileSync('git', [
-                    'log', '-1', '--format=%at', '--', relativePath
+                    '--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -361,7 +362,7 @@ export class GitAnalyzer {
                 const sanitizedKeyword = sanitizeGitArg(keyword);
                 try {
                     const bugFixOutput = execFileSync('git', [
-                        'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
+                        '--literal-pathspecs', 'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
                     ], {
                         cwd: this.config.repoRoot,
                         encoding: 'utf-8',
@@ -410,19 +411,19 @@ export class GitAnalyzer {
         }
         try {
             const sinceDate = since || new Date(Date.now() - 24 * 60 * 60 * 1000);
-            const sinceStr = sinceDate.toISOString().split('T')[0];
+            const sinceStr = sinceDate.toISOString();
             // Get files changed since the date using execFileSync with argument array
             const output = execFileSync('git', [
-                'log', `--since=${sinceStr}`, '--name-only', '--pretty=format:'
+                'log', `--since=${sinceStr}`, '--name-only', '-z', '--format='
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
-            }).trim();
+            });
             if (!output)
                 return [];
-            // Deduplicate and filter empty lines manually (instead of sort -u | grep -v)
-            const files = output.split('\n').filter(Boolean);
+            // NUL records preserve whitespace, newlines and Git-quoted Unicode paths.
+            const files = output.split('\0').filter(Boolean);
             return Array.from(new Set(files));
         }
         catch {
@@ -442,15 +443,15 @@ export class GitAnalyzer {
             // Sanitize commit hash to prevent injection
             const sanitizedHash = sanitizeGitArg(commitHash);
             const output = execFileSync('git', [
-                'diff-tree', '--no-commit-id', '--name-only', '-r', sanitizedHash
+                'diff-tree', '--no-commit-id', '--name-only', '-z', '-r', sanitizedHash
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
-            }).trim();
+            });
             if (!output)
                 return [];
-            return output.split('\n').filter(Boolean);
+            return output.split('\0').filter(Boolean);
         }
         catch {
             return [];
@@ -469,14 +470,14 @@ export class GitAnalyzer {
             // Get unstaged changes using execFileSync with argument array
             try {
                 const unstagedOutput = execFileSync('git', [
-                    'diff', '--name-only', 'HEAD'
+                    'diff', '--name-only', '-z', 'HEAD'
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
                     stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
+                });
                 if (unstagedOutput) {
-                    files.push(...unstagedOutput.split('\n').filter(Boolean));
+                    files.push(...unstagedOutput.split('\0').filter(Boolean));
                 }
             }
             catch {
@@ -485,14 +486,14 @@ export class GitAnalyzer {
             // Get staged changes using execFileSync with argument array
             try {
                 const stagedOutput = execFileSync('git', [
-                    'diff', '--name-only', '--cached'
+                    'diff', '--name-only', '-z', '--cached'
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
                     stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
+                });
                 if (stagedOutput) {
-                    files.push(...stagedOutput.split('\n').filter(Boolean));
+                    files.push(...stagedOutput.split('\0').filter(Boolean));
                 }
             }
             catch {

package/dist/shared/http/http-client.js

@@ -74,8 +74,9 @@ class CircuitBreaker {
             }
             return false;
         }
-        // half-open: allow one request through
-        return true;
+        // The open -> half-open transition already admitted the recovery probe.
+        // Keep further requests out until that probe records success or failure.
+        return false;
     }
     reset(url) {
         if (url) {
@@ -253,17 +254,23 @@ export class HttpClient {
         if (!error) {
             return 'UNKNOWN_ERROR';
         }
-        if (error.name === 'AbortError') {
-            return 'TIMEOUT';
-        }
-        if (error.message.includes('ECONNREFUSED')) {
-            return 'CONNECTION_REFUSED';
-        }
-        if (error.message.includes('ENOTFOUND')) {
-            return 'DNS_ERROR';
-        }
-        if (error.message.includes('ETIMEDOUT')) {
-            return 'NETWORK_TIMEOUT';
+        // Native fetch wraps transport errors in a TypeError whose cause carries
+        // the socket/DNS code. Retain message-based handling for existing callers.
+        const visited = new Set();
+        let current = error;
+        while (typeof current === 'object' && current !== null && !visited.has(current)) {
+            visited.add(current);
+            const detail = current;
+            if (detail.name === 'AbortError')
+                return 'TIMEOUT';
+            const message = typeof detail.message === 'string' ? detail.message : '';
+            if (detail.code === 'ECONNREFUSED' || message.includes('ECONNREFUSED'))
+                return 'CONNECTION_REFUSED';
+            if (detail.code === 'ENOTFOUND' || message.includes('ENOTFOUND'))
+                return 'DNS_ERROR';
+            if (detail.code === 'ETIMEDOUT' || message.includes('ETIMEDOUT'))
+                return 'NETWORK_TIMEOUT';
+            current = detail.cause;
         }
         return 'REQUEST_FAILED';
     }

package/dist/shared/io/file-reader.js

@@ -235,27 +235,30 @@ export class FileReader {
     resolvePath(filePath) {
         // Determine if path is absolute
         const isAbsolutePath = path.isAbsolute(filePath);
+        const normalizedBase = path.resolve(this.basePath);
+        const normalizedPath = path.resolve(normalizedBase, filePath);
+        const relativePath = path.relative(normalizedBase, normalizedPath);
+        if (this.basePath && (relativePath === '..' || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath))) {
+            throw new PathTraversalError(filePath, ['Path escapes base directory'], 'critical');
+        }
+        // Absolute checkout prefixes are not user-controlled depth beneath the root.
+        // Keep validating the original spelling so encoded traversal remains blocked.
+        const baseDepth = this.basePath ? normalizedBase.split(/[\\/]/).filter(Boolean).length : 0;
         // SEC-004 FIX: Validate path to prevent directory traversal
         // For absolute paths, validate without basePath to avoid incorrect combination
         // For relative paths, validate with basePath for proper containment check
         const validation = validatePath(filePath, {
             basePath: isAbsolutePath ? '' : this.basePath,
             allowAbsolute: true,
+            maxDepth: 10 + (isAbsolutePath ? baseDepth : 0),
             // Allow common development file extensions
             deniedExtensions: ['.exe', '.bat', '.cmd', '.ps1', '.dll', '.so'],
         });
         if (!validation.valid) {
             throw new PathTraversalError(filePath, [validation.error || 'Path validation failed'], validation.riskLevel);
         }
-        // For absolute paths, verify they stay within basePath if one is configured
-        if (isAbsolutePath && this.basePath) {
-            const normalizedBase = path.resolve(this.basePath);
-            const normalizedPath = path.resolve(filePath);
-            if (!normalizedPath.startsWith(normalizedBase)) {
-                throw new PathTraversalError(filePath, ['Path escapes base directory'], 'critical');
-            }
+        if (isAbsolutePath)
             return normalizedPath;
-        }
         // Use the normalized path from validation if available
         if (validation.normalizedPath) {
             return validation.normalizedPath;

package/dist/shared/llm/cache.d.ts

@@ -5,7 +5,7 @@
  * Provides efficient caching of LLM responses to reduce costs and latency
  * for repeated queries. Uses LRU (Least Recently Used) eviction policy.
  */
-import { CacheEntry, LLMCacheConfig, LLMCacheStats, LLMResponse, EmbeddingResponse, CompletionResponse } from './interfaces';
+import { CacheEntry, LLMCacheConfig, LLMCacheStats, LLMResponse, EmbeddingResponse, CompletionResponse, type GenerateOptions } from './interfaces';
 /**
  * Default cache configuration
  */
@@ -14,6 +14,7 @@ export declare const DEFAULT_CACHE_CONFIG: LLMCacheConfig;
  * Type for cacheable response types
  */
 export type CacheableResponse = LLMResponse | EmbeddingResponse | CompletionResponse;
+type CacheKeyOptions = Pick<GenerateOptions, 'model' | 'temperature' | 'maxTokens' | 'systemPrompt' | 'stopSequences' | 'effort' | 'preferredProvider'>;
 /**
  * LRU Cache implementation for LLM responses
  */
@@ -28,12 +29,7 @@ export declare class LLMCache<T = CacheableResponse> {
     /**
      * Generate a cache key from request parameters
      */
-    static generateKey(type: 'generation' | 'embedding' | 'completion', input: string, options?: {
-        model?: string;
-        temperature?: number;
-        maxTokens?: number;
-        systemPrompt?: string;
-    }): string;
+    static generateKey(type: 'generation' | 'embedding' | 'completion', input: string, options?: CacheKeyOptions): string;
     /**
      * Get a cached value
      */
@@ -99,21 +95,11 @@ export declare class LLMResponseCache {
     /**
      * Get a cached generation response
      */
-    getGeneration(input: string, options?: {
-        model?: string;
-        temperature?: number;
-        maxTokens?: number;
-        systemPrompt?: string;
-    }): LLMResponse | undefined;
+    getGeneration(input: string, options?: CacheKeyOptions): LLMResponse | undefined;
     /**
      * Cache a generation response
      */
-    setGeneration(input: string, response: LLMResponse, options?: {
-        model?: string;
-        temperature?: number;
-        maxTokens?: number;
-        systemPrompt?: string;
-    }, ttlMs?: number): void;
+    setGeneration(input: string, response: LLMResponse, options?: CacheKeyOptions, ttlMs?: number): void;
     /**
      * Get a cached embedding response
      */
@@ -129,19 +115,11 @@ export declare class LLMResponseCache {
     /**
      * Get a cached completion response
      */
-    getCompletion(prompt: string, options?: {
-        model?: string;
-        temperature?: number;
-        maxTokens?: number;
-    }): CompletionResponse | undefined;
+    getCompletion(prompt: string, options?: CacheKeyOptions): CompletionResponse | undefined;
     /**
      * Cache a completion response
      */
-    setCompletion(prompt: string, response: CompletionResponse, options?: {
-        model?: string;
-        temperature?: number;
-        maxTokens?: number;
-    }, ttlMs?: number): void;
+    setCompletion(prompt: string, response: CompletionResponse, options?: CacheKeyOptions, ttlMs?: number): void;
     /**
      * Get combined cache statistics
      */
@@ -160,4 +138,5 @@ export declare class LLMResponseCache {
      */
     pruneExpired(): number;
 }
+export {};
 //# sourceMappingURL=cache.d.ts.map

package/dist/shared/llm/cache.js

@@ -42,6 +42,10 @@ export class LLMCache {
             options?.systemPrompt ?? '',
             input,
         ];
+        const outputOptions = [options?.stopSequences, options?.effort, options?.preferredProvider];
+        if (outputOptions.some(value => value !== undefined)) {
+            parts.push(JSON.stringify(outputOptions));
+        }
         // Encode field boundaries before hashing: prompt text may contain delimiters.
         const hash = createHash('sha256').update(JSON.stringify(parts)).digest('hex');
         return `${type}:${hash}`;
@@ -220,14 +224,14 @@ export class LLMCache {
         if (this.accessOrder.length === 0) {
             // Fallback: delete first entry
             const firstKey = this.cache.keys().next().value;
-            if (firstKey) {
+            if (firstKey !== undefined) {
                 this.cache.delete(firstKey);
                 this.evictions++;
             }
             return;
         }
         const lruKey = this.accessOrder.shift();
-        if (lruKey) {
+        if (lruKey !== undefined) {
             this.cache.delete(lruKey);
             this.evictions++;
         }

package/dist/shared/llm/cost-tracker.js

@@ -244,7 +244,8 @@ export class CostTracker {
         for (const record of relevantRecords) {
             totalCost += record.cost.totalCost;
             totalTokens += record.usage.totalTokens;
-            byProvider[record.provider] += record.cost.totalCost;
+            const providerCost = Object.hasOwn(byProvider, record.provider) ? byProvider[record.provider] : 0;
+            byProvider[record.provider] = providerCost + record.cost.totalCost;
             byModel[record.model] = (byModel[record.model] || 0) + record.cost.totalCost;
         }
         return {

package/dist/shared/llm/provider-manager.js

@@ -207,12 +207,7 @@ export class ProviderManager {
         // Check cache first
         if (!options?.skipCache) {
             const inputStr = typeof input === 'string' ? input : JSON.stringify(input);
-            const cached = this.cache.getGeneration(inputStr, {
-                model: options?.model,
-                temperature: options?.temperature,
-                maxTokens: options?.maxTokens,
-                systemPrompt: options?.systemPrompt,
-            });
+            const cached = this.cache.getGeneration(inputStr, options);
             if (cached) {
                 return { ...cached, cached: true };
             }
@@ -224,12 +219,7 @@ export class ProviderManager {
         // Cache the response
         if (!options?.skipCache) {
             const inputStr = typeof input === 'string' ? input : JSON.stringify(input);
-            this.cache.setGeneration(inputStr, response, {
-                model: options?.model,
-                temperature: options?.temperature,
-                maxTokens: options?.maxTokens,
-                systemPrompt: options?.systemPrompt,
-            });
+            this.cache.setGeneration(inputStr, response, options);
         }
         // Track cost (in-process) and persist to the cross-process ledger.
         this.costTracker.recordUsage(response.provider, response.model, response.usage, response.requestId);
@@ -265,11 +255,7 @@ export class ProviderManager {
         await this.ensureInitialized();
         // Check cache first
         if (!options?.skipCache) {
-            const cached = this.cache.getCompletion(prompt, {
-                model: options?.model,
-                temperature: options?.temperature,
-                maxTokens: options?.maxTokens,
-            });
+            const cached = this.cache.getCompletion(prompt, options);
             if (cached) {
                 return { ...cached, cached: true };
             }
@@ -279,11 +265,7 @@ export class ProviderManager {
         const response = await this.executeWithFailover('complete', async (provider) => provider.complete(prompt, options));
         // Cache the response
         if (!options?.skipCache) {
-            this.cache.setCompletion(prompt, response, {
-                model: options?.model,
-                temperature: options?.temperature,
-                maxTokens: options?.maxTokens,
-            });
+            this.cache.setCompletion(prompt, response, options);
         }
         // ADR-123: persist to the cross-process ledger (completion has usage too).
         this.costTracker.recordUsage(response.provider, response.model, response.usage, `complete-${response.model}-${Date.now()}`);

package/dist/shared/llm/providers/gemini.d.ts

@@ -100,6 +100,7 @@ export declare class GeminiProvider implements LLMProvider {
      * Format input to Gemini contents format
      */
     private formatContents;
+    private isPromptBlocked;
     /**
      * Map Gemini finish reason to standard format
      */

package/dist/shared/llm/providers/gemini.js

@@ -191,7 +191,10 @@ export class GeminiProvider {
                 totalTokens: usage.totalTokens,
                 estimatedCostUsd: cost.totalCost,
             });
-            const content = data.candidates[0]?.content?.parts
+            // A blocked prompt has no candidates; preserve it as a terminal result.
+            const blocked = this.isPromptBlocked(data.promptFeedback);
+            const candidate = blocked ? undefined : data.candidates[0];
+            const content = candidate?.content?.parts
                 ?.map(p => p.text ?? '')
                 .join('') ?? '';
             return {
@@ -201,7 +204,7 @@ export class GeminiProvider {
                 usage,
                 cost,
                 latencyMs,
-                finishReason: this.mapFinishReason(data.candidates[0]?.finishReason),
+                finishReason: blocked ? 'content_filter' : this.mapFinishReason(candidate?.finishReason),
                 cached: false,
                 requestId,
             };
@@ -269,10 +272,10 @@ export class GeminiProvider {
                 buffer = lines.pop() || '';
                 for (const line of lines) {
                     const trimmed = line.trim();
-                    if (!trimmed || !trimmed.startsWith('data: '))
+                    if (!trimmed || !trimmed.startsWith('data:'))
                         continue;
                     try {
-                        const chunk = safeJsonParse(trimmed.slice(6));
+                        const chunk = safeJsonParse(trimmed.slice(5).trimStart());
                         const text = chunk.candidates?.[0]?.content?.parts
                             ?.map(p => p.text ?? '')
                             .join('') ?? '';
@@ -280,7 +283,10 @@ export class GeminiProvider {
                             fullContent += text;
                             yield text;
                         }
-                        if (chunk.candidates?.[0]?.finishReason) {
+                        if (this.isPromptBlocked(chunk.promptFeedback)) {
+                            finishReason = 'content_filter';
+                        }
+                        else if (chunk.candidates?.[0]?.finishReason) {
                             finishReason = this.mapFinishReason(chunk.candidates[0].finishReason);
                         }
                         if (chunk.usageMetadata) {
@@ -479,6 +485,9 @@ export class GeminiProvider {
             parts: [{ text: m.content }],
         }));
     }
+    isPromptBlocked(feedback) {
+        return !!feedback?.blockReason && feedback.blockReason !== 'BLOCK_REASON_UNSPECIFIED';
+    }
     /**
      * Map Gemini finish reason to standard format
      */

package/dist/shared/llm/providers/openrouter.js

@@ -299,11 +299,14 @@ export class OpenRouterProvider {
                 buffer = lines.pop() || '';
                 for (const line of lines) {
                     const trimmed = line.trim();
-                    if (!trimmed || trimmed === 'data: [DONE]')
+                    if (!trimmed || !trimmed.startsWith('data:'))
                         continue;
-                    if (trimmed.startsWith('data: ')) {
+                    const data = trimmed.slice(5).trimStart();
+                    if (data === '[DONE]')
+                        continue;
+                    if (trimmed.startsWith('data:')) {
                         try {
-                            const chunk = safeJsonParse(trimmed.slice(6));
+                            const chunk = safeJsonParse(data);
                             const delta = chunk.choices[0]?.delta;
                             if (delta?.content) {
                                 fullContent += delta.content;

package/dist/shared/metrics/code-metrics.js

@@ -228,7 +228,7 @@ export class CodeMetricsAnalyzer {
         // Count decision points
         const decisionPatterns = [
             /\bif\s*\(/g,
-            /\belse\s+if\s*\(/g,
+            // The if pattern already counts else-if decisions.
             /\bfor\s*\(/g,
             /\bwhile\s*\(/g,
             /\bcase\s+/g,

package/dist/shared/metrics/system-metrics.js

@@ -76,7 +76,13 @@ export class SystemMetricsCollector {
      */
     collectProcessMetrics() {
         const memUsage = process.memoryUsage();
-        const cpuUsage = process.cpuUsage(this.lastCpuUsage ?? undefined);
+        const currentCpuUsage = process.cpuUsage();
+        const cpuUsage = this.lastCpuUsage
+            ? {
+                user: currentCpuUsage.user - this.lastCpuUsage.user,
+                system: currentCpuUsage.system - this.lastCpuUsage.system,
+            }
+            : currentCpuUsage;
         // Calculate CPU percentage
         const now = Date.now();
         const elapsedMs = this.lastCpuTime > 0 ? now - this.lastCpuTime : 1000;
@@ -85,7 +91,7 @@ export class SystemMetricsCollector {
         const totalCpuUs = cpuUsage.user + cpuUsage.system;
         const cpuPercent = (totalCpuUs / elapsedUs) * 100;
         // Update last values
-        this.lastCpuUsage = cpuUsage;
+        this.lastCpuUsage = currentCpuUsage;
         this.lastCpuTime = now;
         // Calculate memory percentage
         const totalMem = os.totalmem();

package/dist/shared/retry-engine.js

@@ -1,14 +1,4 @@
-/**
- * Agentic QE v3 - Unified Retry Engine
- * IMP-03: Retry Engine with Exponential Backoff
- *
- * Provides a single, well-tested retry loop with exponential backoff,
- * jitter, abort signal support, and retryable-error classification.
- *
- * The circuit breaker (circuit-breaker.ts) is a separate concern that
- * receives success/failure signals from callers — this engine does NOT
- * import or depend on it. Integration is planned for a later phase.
- */
+import { isCallerInputError } from './error-utils.js';
 // ---------------------------------------------------------------------------
 // Defaults
 // ---------------------------------------------------------------------------
@@ -59,7 +49,7 @@ const NON_RETRYABLE_HTTP_STATUSES = new Set([400, 401, 403, 404, 422]);
  * Returns `false` for recognised non-retryable client errors (4xx).
  */
 export function isRetryableError(error) {
-    if (error == null)
+    if (error == null || isCallerInputError(error))
         return false;
     // --- code property (errno) -------------------------------------------
     const code = error.code;