locai 2.6.2 → 2.7.0

package/dist/core/orchestrator.js

@@ -7,8 +7,6 @@ import { LRUCache } from "lru-cache";
 import os from "os";
 import gracefulShutdown from "../utils/graceful-shutdown.js";
 import GlossaryManager from "../utils/glossary-manager.js";
-import fs from "fs";
-import path from "path";
 import { log } from "../utils/logger.js";
 // Pipeline imports
 import Pipeline from "./pipeline/Pipeline.js";
@@ -24,6 +22,7 @@ import ConfidenceCheckStep from "./pipeline/steps/ConfidenceCheckStep.js";
 import CacheWriteStep from "./pipeline/steps/CacheWriteStep.js";
 import ContextEnrichmentStep from "./pipeline/steps/ContextEnrichmentStep.js";
 import { SourceCodeAnalyzer } from "../services/source-analyzer.js";
+import { updateReviewQueue } from "../utils/review-queue.js";
 // Vector Memory Imports
 import { VectorStore } from "../services/vector-store.js";
 import { EmbeddingProvider } from "../services/embedding-provider.js";
@@ -36,7 +35,6 @@ class Orchestrator {
     qualityChecker;
     advanced;
     glossaryManager;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     translationCache;
     cacheStats;
     // Vector Memory
@@ -87,47 +85,29 @@ class Orchestrator {
             max: options.cacheSize || 1000,
             ttl: options.cacheTTL || 1000 * 60 * 60 * 24,
             updateAgeOnGet: options.updateAgeOnGet !== false,
-            allowStale: options.allowStaleCache !== false,
-            // Simplified fetchMethod for stale-while-revalidate pattern
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            fetchMethod: async (key, staleValue, { context }) => {
-                if (staleValue && options.staleWhileRevalidate !== false) {
-                    // Background refresh using a mini-pipeline or direct logic
-                    this._refreshCacheEntry(key, context).catch((err) => {
-                        console.warn(`Cache refresh failed for key ${key}: ${err.message}`);
-                    });
-                    return staleValue;
-                }
-                return null;
-            },
         });
         this.cacheStats = {
             hits: 0,
             misses: 0,
-            staleHits: 0,
             stored: 0,
-            refreshes: 0,
         };
-        // Confidence scoring settings
+        // Confidence scoring: turned on by `confidenceScoring.enabled` or by the top-level
+        // minConfidence / saveReviewQueue (the --min-confidence / --save-review-queue flags)
+        const scoring = options.confidenceScoring;
+        const sectionReviewThresholds = [scoring?.minConfidence, scoring?.reviewThreshold].filter((threshold) => threshold !== undefined);
         this.confidenceSettings = {
             enabled: options.minConfidence !== undefined ||
-                options.saveReviewQueue ||
-                options.confidenceScoring?.enabled ||
-                false,
-            autoApproveThreshold: options.confidenceScoring?.autoApproveThreshold || 0.9,
-            reviewThreshold: options.confidenceScoring?.reviewThreshold || 0.7,
-            rejectThreshold: options.confidenceScoring?.rejectThreshold || 0.5,
-            saveReviewQueue: options.saveReviewQueue || options.confidenceScoring?.saveReviewQueue || false,
+                Boolean(options.saveReviewQueue || scoring?.enabled),
+            autoApproveThreshold: scoring?.autoApproveThreshold ?? 0.9,
+            reviewThreshold: options.minConfidence ??
+                (sectionReviewThresholds.length > 0 ? Math.max(...sectionReviewThresholds) : 0.7),
+            rejectThreshold: scoring?.rejectThreshold ?? 0.5,
+            saveReviewQueue: Boolean(options.saveReviewQueue || scoring?.saveReviewQueue),
             reviewQueue: [],
+            scored: [],
             autoApprovedCount: 0,
             rejectedCount: 0,
         };
-        // Use minConfidence from options if present as specific threshold logic override or mapping
-        if (options.minConfidence) {
-            // This logic was slightly fuzzy in JS, preserved here:
-            // If minConfidence is set, it might override others or act as a floor.
-            // The original code used it.
-        }
         this.concurrencyLimit = options.concurrencyLimit || 5;
         if (this.advanced.autoOptimize) {
             this._applyAutoOptimizations();
@@ -223,7 +203,7 @@ class Orchestrator {
             enabled: this.options.styleGuide?.enforceTone,
             debug: this.advanced.debug,
         }));
-        // 7. Confidence Score Calculationk
+        // 7. Confidence thresholds (scores are computed by TranslationStep)
         this.pipeline.use(new ConfidenceCheckStep(this.confidenceSettings, this.advanced.debug));
         // 8. Cache Write
         if (this.translationCache) {
@@ -232,15 +212,37 @@ class Orchestrator {
             }));
         }
     }
-    async processTranslation(key, text, targetLang, 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    contextData, 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    existingTranslation) {
+    async processTranslation(key, text, targetLang, contextData, existingTranslation) {
         const context = createTranslationContext(key, text, this.options.source, targetLang, this.options, contextData, existingTranslation);
         await this.pipeline.execute(context);
+        this._recordConfidence(context);
         return context.result;
     }
+    /** Count a scored translation and queue it when it needs review or was rejected. */
+    _recordConfidence({ key, sourceText, sourceLang, targetLang, meta, result, }) {
+        const settings = this.confidenceSettings;
+        if (!settings.enabled || !result.confidence) {
+            return;
+        }
+        settings.scored.push({ language: targetLang, key });
+        if (result.autoApproved)
+            settings.autoApprovedCount++;
+        if (result.rejected)
+            settings.rejectedCount++;
+        if ((result.needsReview || result.rejected) && result.translated) {
+            settings.reviewQueue.push({
+                key,
+                language: targetLang,
+                source: sourceText,
+                translation: result.translated,
+                confidence: result.confidence,
+                sourceLang,
+                category: meta.category || "general",
+                rejected: result.rejected === true,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
     async processTranslations(items) {
         this.progress.start(items.length, items[0].targetLang);
         const limit = pLimit(this.concurrencyLimit);
@@ -249,17 +251,16 @@ class Orchestrator {
         if (this.advanced.debug) {
             log(`Processing ${items.length} items with concurrency limit ${this.concurrencyLimit}`, true);
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const allPromises = [];
         for (const chunk of chunks) {
             const texts = chunk.map((item) => item.text);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             let contextResults = [];
             try {
                 contextResults = await this.contextProcessor.analyzeBatch(texts);
             }
             catch (error) {
-                console.warn(`Context analysis failed for batch: ${error.message}`);
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`Context analysis failed for batch: ${message}`);
             }
             for (let i = 0; i < chunk.length; i++) {
                 const item = chunk[i];
@@ -275,7 +276,7 @@ class Orchestrator {
                         return {
                             key: item.key,
                             translated: item.text,
-                            error: error.message,
+                            error: error instanceof Error ? error.message : String(error),
                             success: false,
                             context: {},
                         };
@@ -288,9 +289,7 @@ class Orchestrator {
         return processedResults;
     }
     // Helper methods
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _chunkArray(array, chunkSize) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const chunks = [];
         for (let i = 0; i < array.length; i += chunkSize) {
             chunks.push(array.slice(i, i + chunkSize));
@@ -316,7 +315,8 @@ class Orchestrator {
             }
         }
         catch (error) {
-            console.warn("Failed to auto-optimize settings:", error.message);
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn("Failed to auto-optimize settings:", message);
         }
     }
     clearCache() {
@@ -329,12 +329,9 @@ class Orchestrator {
         this.cacheStats = {
             hits: 0,
             misses: 0,
-            staleHits: 0,
             stored: 0,
-            refreshes: 0,
         };
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getCacheStats() {
         if (!this.translationCache)
             return {};
@@ -345,30 +342,6 @@ class Orchestrator {
             hitRate: this.cacheStats.hits / (this.cacheStats.hits + this.cacheStats.misses) || 0,
         };
     }
-    // Used by background revalidation.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async _refreshCacheEntry(key, context) {
-        if (!context || !context.text || !context.targetLang) {
-            return;
-        }
-        try {
-            // Use the full pipeline for refresh, but skip cache read to force re-translation
-            // pass specific options merged with global options
-            const refreshOptions = {
-                ...this.options,
-                skipCache: true,
-                staleWhileRevalidate: false, // Prevent infinite recursion matching this condition
-            };
-            const ctx = createTranslationContext(key, context.text, this.options.source, context.targetLang, refreshOptions, context.contextData);
-            await this.pipeline.execute(ctx);
-            // Stats are handled within steps (TranslationStep adds confidence, CacheWriteStep updates cache & stats)
-            this.cacheStats.refreshes++;
-        }
-        catch (error) {
-            console.warn(`Failed to refresh cache entry: ${error.message}`);
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getStatus() {
         return {
             cache: this.getCacheStats(),
@@ -388,58 +361,25 @@ class Orchestrator {
                 : null,
         };
     }
+    /**
+     * Add the translations this orchestrator flagged to `.localize-cache/review-queue.json`,
+     * when saving the review queue is enabled.
+     */
     saveReviewQueue() {
-        if (!this.confidenceSettings.saveReviewQueue ||
-            this.confidenceSettings.reviewQueue.length === 0) {
+        if (!this.confidenceSettings.saveReviewQueue) {
             return;
         }
         try {
-            const cacheDir = path.join(process.cwd(), ".localize-cache");
-            if (!fs.existsSync(cacheDir)) {
-                fs.mkdirSync(cacheDir, { recursive: true });
-            }
-            const reviewFile = path.join(cacheDir, "review-queue.json");
-            const data = {
-                timestamp: new Date().toISOString(),
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                minConfidence: this.options.minConfidence,
-                items: this.confidenceSettings.reviewQueue,
-                stats: {
-                    total: this.confidenceSettings.reviewQueue.length,
-                    byLanguage: this._groupByLanguage(this.confidenceSettings.reviewQueue),
-                    byConfidenceLevel: this._groupByConfidenceLevel(this.confidenceSettings.reviewQueue),
-                },
-            };
-            fs.writeFileSync(reviewFile, JSON.stringify(data, null, 2));
-            console.log(`\nReview queue saved: ${this.confidenceSettings.reviewQueue.length} items need review`);
-            console.log(`   File: ${reviewFile}`);
-            console.log(`   Run 'localize review' to start interactive review\n`);
+            const { file, size } = updateReviewQueue(this.confidenceSettings.scored, this.confidenceSettings.reviewQueue);
+            console.log(`\nReview queue saved: ${size} items need review`);
+            console.log(`   File: ${file}`);
+            console.log(`   Run 'locai review' to start interactive review\n`);
         }
         catch (error) {
-            console.warn(`Warning: Failed to save review queue: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Warning: Failed to save review queue: ${message}`);
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _groupByLanguage(items) {
-        const grouped = {};
-        items.forEach((item) => {
-            if (!grouped[item.language]) {
-                grouped[item.language] = 0;
-            }
-            grouped[item.language]++;
-        });
-        return grouped;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _groupByConfidenceLevel(items) {
-        const grouped = { high: 0, medium: 0, low: 0, very_low: 0 };
-        items.forEach((item) => {
-            if (grouped[item.confidence.level] !== undefined) {
-                grouped[item.confidence.level]++;
-            }
-        });
-        return grouped;
-    }
     destroy() {
         if (this.translationCache) {
             this.translationCache.clear();

package/dist/core/pipeline/Pipeline.d.ts

@@ -5,14 +5,14 @@ import { TranslationContext } from "./context.js";
  * Allows composing a sequence of steps that can process a context object.
  */
 declare class Pipeline {
-    steps: any[];
+    steps: PipelineStep[];
     constructor();
     /**
      * Add a step to the pipeline.
      * @param step - A step instance with an execute(context, next) method.
      * @returns - Returns self for chaining.
      */
-    use(step: PipelineStep | any): Pipeline;
+    use(step: PipelineStep): Pipeline;
     /**
      * Execute the pipeline with the given context.
      * @param context - The context object to be processed.

package/dist/core/pipeline/Pipeline.js

@@ -3,8 +3,7 @@
  * Allows composing a sequence of steps that can process a context object.
  */
 class Pipeline {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    steps = []; // allow loose typing initially for step inputs, but ideally PipelineStep
+    steps = [];
     constructor() {
         this.steps = [];
     }
@@ -13,7 +12,6 @@ class Pipeline {
      * @param step - A step instance with an execute(context, next) method.
      * @returns - Returns self for chaining.
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     use(step) {
         if (!step || typeof step.execute !== "function") {
             throw new Error("Pipeline step must implement an execute(context, next) method.");

package/dist/core/pipeline/context.d.ts

@@ -1,29 +1,85 @@
+import type { CodeContext } from "../../types/context.js";
+import type { AnalysisResult } from "../context-processor.js";
+import type { OrchestratorOptions } from "../orchestrator.js";
+import type { ConfidenceResult } from "../../utils/confidence-scorer.js";
+import type { ProtectedTerm } from "../../utils/glossary-manager.js";
+import type { FlatTranslationValue } from "../../utils/object-transformer.js";
+import type { FixResult, QualityIssue } from "../../utils/quality/base-checker.js";
+/** A stored translation of similar source text, found in vector memory. */
+export interface SimilarTranslation {
+    source: string;
+    target: string;
+    similarity: number;
+}
+/**
+ * What is known about the text being translated: its detected category (see
+ * ContextProcessor) plus what the pipeline steps add. Forwarded to the provider as
+ * `detectedContext` and returned as the result's `context`.
+ */
+export interface TranslationMeta extends Partial<AnalysisResult> {
+    /** Where the key is used in the project's source code (ContextEnrichmentStep). */
+    code?: CodeContext;
+    /** Embedding of the source text, computed by VectorCacheReadStep and reused by VectorCacheWriteStep. */
+    embedding?: number[];
+    /** Close vector-memory match, offered to the provider as a reference translation. */
+    similarTranslation?: SimilarTranslation;
+    /** Set on results served directly from vector memory. */
+    matchType?: "vector-exact";
+    similarity?: number;
+}
+/** Tone mismatch reported by ToneCheckStep. */
+export interface ToneIssue {
+    type: "tone_mismatch";
+    message: string;
+    severity: "warning";
+    suggestion?: string;
+    score: number;
+}
+/** Quality findings of a translation: the quality checker's fix result and any tone issues. */
+export interface QualityReport extends Partial<Omit<FixResult, "issues">> {
+    issues: (QualityIssue | ToneIssue)[];
+}
 export interface TranslationResult {
     key: string;
     translated: string | null;
     success: boolean;
-    context: Record<string, any>;
+    context: TranslationMeta;
     error?: string;
     fromCache?: boolean;
-    qualityChecks?: any;
-    meta?: Record<string, any>;
+    qualityChecks?: QualityReport;
+    /** Set on results served directly from vector memory. */
+    meta?: {
+        vectorMatch: boolean;
+        similarity: number;
+    };
+    confidence?: ConfidenceResult;
+    autoApproved?: boolean;
+    rejected?: boolean;
+    rejectionReason?: string;
+    needsReview?: boolean;
 }
+/** Options visible to the pipeline steps: the orchestrator options. */
+export type PipelineOptions = OrchestratorOptions;
+/** State shared by the pipeline steps while one key is translated. */
 export interface TranslationContext {
     key: string;
     sourceText: string;
     sourceLang: string;
     targetLang: string;
-    options: any;
-    meta: Record<string, any>;
-    existingTranslation: any;
+    options: PipelineOptions;
+    meta: TranslationMeta;
+    /** Current value of the key in the target file, or null when there is none. */
+    existingTranslation: FlatTranslationValue;
     result: TranslationResult;
+    /** Cache key computed by CacheReadStep, used by CacheWriteStep. */
+    cacheKey?: string;
+    /** Source text with glossary terms replaced by placeholder tokens (GlossaryPreStep). */
     protectedText?: string;
-    termMap?: Map<string, any>;
+    /** Placeholder token → protected glossary term, used by GlossaryPostStep. */
+    termMap?: Map<string, ProtectedTerm>;
     translatedText?: string;
-    success?: boolean;
-    error?: string;
-    fromCache?: boolean;
-    qualityChecks?: any;
-    [key: string]: any;
+    /** Confidence score of the translation, when the provider supports scoring. */
+    confidence?: ConfidenceResult;
+    qualityResult?: QualityReport;
 }
-export declare const createTranslationContext: (key: string, sourceText: string, sourceLang: string, targetLang: string, options: any, meta?: Record<string, any>, existingTranslation?: any) => TranslationContext;
+export declare const createTranslationContext: (key: string, sourceText: string, sourceLang: string, targetLang: string, options: PipelineOptions, meta?: TranslationMeta, existingTranslation?: FlatTranslationValue) => TranslationContext;

package/dist/core/pipeline/context.js

@@ -1,10 +1,4 @@
-export const createTranslationContext = (key, sourceText, sourceLang, targetLang, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-options, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-meta = {}, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-existingTranslation = null) => ({
+export const createTranslationContext = (key, sourceText, sourceLang, targetLang, options, meta = {}, existingTranslation = null) => ({
     key,
     sourceText,
     sourceLang,

package/dist/core/pipeline/steps/CacheReadStep.d.ts

@@ -1,24 +1,27 @@
 import PipelineStep from "../PipelineStep.js";
-import { TranslationContext } from "../context.js";
+import { TranslationContext, TranslationResult } from "../context.js";
+/** Translation cache counters, shared by the orchestrator and the cache steps. */
 export interface CacheStats {
     hits: number;
-    staleHits: number;
     misses: number;
     stored: number;
-    [key: string]: any;
 }
+/** The part of the translation cache (an LRUCache) the cache steps use. */
 export interface Cache {
     has(key: string): boolean;
-    get(key: string): any;
-    set(key: string, value: any, options?: any): void;
+    get(key: string): TranslationResult | undefined;
+    set(key: string, value: TranslationResult): void;
     delete(key: string): void;
-    getRemainingTTL?(key: string): number;
+}
+export interface CacheStepOptions {
+    /** Set to false to bypass the cache (default enabled). */
+    enabled?: boolean;
 }
 declare class CacheReadStep extends PipelineStep {
     private cache;
     private stats;
     private options;
-    constructor(cache: Cache, cacheStats: CacheStats, options?: any);
+    constructor(cache: Cache, cacheStats: CacheStats, options?: CacheStepOptions);
     execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
     _generateCacheKey(text: string, targetLang: string, category?: string): string;
 }

package/dist/core/pipeline/steps/CacheReadStep.js

@@ -3,7 +3,6 @@ import crypto from "crypto";
 class CacheReadStep extends PipelineStep {
     cache;
     stats;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     options;
     constructor(cache, cacheStats, options = {}) {
         super();
@@ -12,7 +11,7 @@ class CacheReadStep extends PipelineStep {
         this.options = options;
     }
     async execute(context, next) {
-        if (this.options.enabled === false || context.options?.skipCache) {
+        if (this.options.enabled === false) {
             await next();
             return;
         }
@@ -21,16 +20,6 @@ class CacheReadStep extends PipelineStep {
             const cachedResult = this.cache.get(cacheKey);
             if (cachedResult && typeof cachedResult === "object") {
                 this.stats.hits++;
-                // Check for stale hit
-                try {
-                    const ttl = this.cache.getRemainingTTL?.(cacheKey);
-                    if (typeof ttl === "number" && ttl <= 0) {
-                        this.stats.staleHits++;
-                    }
-                }
-                catch (_error) {
-                    // Ignore cache errors
-                }
                 // Hydrate context result from cache
                 context.result = {
                     ...cachedResult,

package/dist/core/pipeline/steps/CacheWriteStep.d.ts

@@ -1,11 +1,11 @@
 import PipelineStep from "../PipelineStep.js";
 import { TranslationContext } from "../context.js";
-import { Cache, CacheStats } from "./CacheReadStep.js";
+import { Cache, CacheStats, CacheStepOptions } from "./CacheReadStep.js";
 declare class CacheWriteStep extends PipelineStep {
     private cache;
     private stats;
     private options;
-    constructor(cache: Cache, cacheStats: CacheStats, options?: any);
+    constructor(cache: Cache, cacheStats: CacheStats, options?: CacheStepOptions);
     execute(context: TranslationContext, next: () => Promise<void>): Promise<void>;
 }
 export default CacheWriteStep;

package/dist/core/pipeline/steps/CacheWriteStep.js

@@ -2,7 +2,6 @@ import PipelineStep from "../PipelineStep.js";
 class CacheWriteStep extends PipelineStep {
     cache;
     stats;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     options;
     constructor(cache, cacheStats, options = {}) {
         super();
@@ -17,13 +16,7 @@ class CacheWriteStep extends PipelineStep {
             context.result.success &&
             !context.result.fromCache &&
             context.cacheKey) {
-            this.cache.set(context.cacheKey, context.result, {
-                context: {
-                    text: context.sourceText,
-                    targetLang: context.targetLang,
-                    contextData: context.meta,
-                },
-            });
+            this.cache.set(context.cacheKey, context.result);
             this.stats.stored++;
         }
         await next();

package/dist/core/pipeline/steps/ConfidenceCheckStep.d.ts

@@ -1,6 +1,11 @@
 import PipelineStep from "../PipelineStep.js";
 import { TranslationContext } from "../context.js";
 import { ConfidenceSettings } from "./TranslationStep.js";
+/**
+ * Classifies a scored translation by the confidence thresholds: below rejectThreshold it is
+ * rejected (the result fails, so the translation is not written), below reviewThreshold it
+ * needs review, at or above autoApproveThreshold it is auto-approved.
+ */
 declare class ConfidenceCheckStep extends PipelineStep {
     private confidenceSettings;
     private debug;

package/dist/core/pipeline/steps/ConfidenceCheckStep.js

@@ -1,5 +1,10 @@
 import PipelineStep from "../PipelineStep.js";
 import { log } from "../../../utils/logger.js";
+/**
+ * Classifies a scored translation by the confidence thresholds: below rejectThreshold it is
+ * rejected (the result fails, so the translation is not written), below reviewThreshold it
+ * needs review, at or above autoApproveThreshold it is auto-approved.
+ */
 class ConfidenceCheckStep extends PipelineStep {
     confidenceSettings;
     debug;
@@ -9,57 +14,32 @@ class ConfidenceCheckStep extends PipelineStep {
         this.debug = debug;
     }
     async execute(context, next) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        if (!context.confidence || !this.confidenceSettings.enabled) {
+        const { confidence, result } = context;
+        if (!this.confidenceSettings.enabled || !confidence || !result.success) {
             await next();
             return;
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const confidence = context.confidence;
-        const result = context.result;
+        const { autoApproveThreshold = 0.9, reviewThreshold = 0.7, rejectThreshold = 0.5, } = this.confidenceSettings;
+        const score = confidence.score;
         result.confidence = confidence;
-        // Auto-approve if above threshold
-        if (this.confidenceSettings.autoApproveThreshold !== undefined &&
-            confidence.score >= this.confidenceSettings.autoApproveThreshold) {
-            result.autoApproved = true;
-            if (this.confidenceSettings.autoApprovedCount !== undefined) {
-                this.confidenceSettings.autoApprovedCount++;
-            }
-            if (this.debug) {
-                log(`Auto-approved: ${context.key} (score: ${confidence.score.toFixed(3)})`, true);
-            }
-        }
-        // Auto-reject if below threshold
-        else if (this.confidenceSettings.rejectThreshold !== undefined &&
-            confidence.score < this.confidenceSettings.rejectThreshold) {
+        let outcome = "Accepted";
+        if (score < rejectThreshold) {
+            outcome = "Rejected";
             result.rejected = true;
-            result.rejectionReason = `Quality score too low: ${confidence.score.toFixed(3)}`;
-            if (this.confidenceSettings.rejectedCount !== undefined) {
-                this.confidenceSettings.rejectedCount++;
-            }
-            if (this.debug) {
-                log(`Auto-rejected: ${context.key} (score: ${confidence.score.toFixed(3)})`, true);
-            }
-            // Keep original text for rejected translations
-            result.translated = context.sourceText;
+            result.rejectionReason = `Confidence ${score.toFixed(3)} is below the reject threshold ${rejectThreshold}`;
+            result.error = result.rejectionReason;
+            result.success = false;
         }
-        // Add to review queue if below review threshold
-        else if (this.confidenceSettings.saveReviewQueue &&
-            this.confidenceSettings.reviewThreshold !== undefined &&
-            confidence.score < this.confidenceSettings.reviewThreshold) {
+        else if (score < reviewThreshold) {
+            outcome = "Needs review";
             result.needsReview = true;
-            if (this.confidenceSettings.reviewQueue) {
-                this.confidenceSettings.reviewQueue.push({
-                    key: context.key,
-                    source: context.sourceText,
-                    translation: context.translatedText,
-                    confidence,
-                    language: context.targetLang,
-                    sourceLang: context.options.source,
-                    category: context.meta?.category || "general",
-                    timestamp: new Date().toISOString(),
-                });
-            }
+        }
+        else if (score >= autoApproveThreshold) {
+            outcome = "Auto-approved";
+            result.autoApproved = true;
+        }
+        if (this.debug) {
+            log(`${outcome}: ${context.key} (score: ${score.toFixed(3)})`, true);
         }
         await next();
     }