index.js

// Context Truncator with Summarization
// Based on Qvink Memory by Qvink, simplified and adapted for context truncation

import {
    getStringHash,
    debounce,
    trimToEndSentence,
} from '../../../utils.js';

import {
    animation_duration,
    scrollChatToBottom,
    saveSettingsDebounced,
    getMaxContextSize,
    streamingProcessor,
    amount_gen,
    extension_prompt_roles,
    extension_prompt_types,
    chat_metadata,
    generateRaw,
} from '../../../../script.js';

import { 
    getContext, 
    extension_settings, 
    saveMetadataDebounced 
} from '../../../extensions.js';

import { itemizedPrompts } from '../../../../scripts/itemized-prompts.js';

export { MODULE_NAME };

// Module constants
const MODULE_NAME = 'context_truncator';
const MODULE_NAME_FANCY = 'CacheGuard';

// Default settings
const default_settings = {
    // ==================== TRUNCATION SETTINGS ====================
    enabled: true,
    target_context_size: 8000,      // Target size in tokens
    batch_size: 20,                 // Messages per batch
    min_messages_to_keep: 10,       // Safety limit
    
    // Auto-calibration settings
    auto_calibrate_target: true,   // Enable auto-calibration
    target_utilization: 0.80,       // Target 80% of max context
    calibration_tolerance: 0.05,    // 5% tolerance before recalibrating
    
    // Summary injection limits (V22)
    auto_limit_summaries: true,     // Auto-calculate max summary tokens (20% of target budget)
    max_summary_injection_tokens: 10000,  // Manual override when auto_limit_summaries is false (0 = unlimited)
    
    // Summarization settings
    auto_summarize: false,
    connection_profile: "",         // DEPRECATED: Connection profile dropdown removed — summarization uses independent summary_endpoint_url
    summary_endpoint_url: "",       // REQ-003: OpenAI-compatible summary endpoint URL (empty = use generateRaw)
    summary_max_words: 50,          // Maximum words per summary
    summary_endpoint_timeout: 15000,  // Timeout in ms (increased from 10s)
    summary_request_delay: 500,       // Delay between requests in ms
    summary_max_retries: 3,           // Max retry attempts on transient errors
    summary_max_tokens: 800,          // Max tokens for summary generation (increased for GLM-4 compatibility)
    summary_prompt: `Summarize the following roleplay message into a single, dense sentence.

NAMES: {{user}} is the user's character. {{char}} is the AI character.

RULES:
• Output ONLY the summary - nothing else
• ONE sentence in past tense, max {{words}} words
• Start with speaker label: "{{char}}:", "{{user}}:", or "Narrator:"
• Focus on: actions, decisions, emotions, key plot/worldbuilding details
• Never add information not in the original message
• Never include reasoning, explanations, or meta-commentary
• Never use tags like <think>, </think>, or similar
• Stop immediately after the summary sentence

EXAMPLES:
• "{{char}}: Accepted the apology but remained emotionally guarded."
• "{{user}}: Proposed exploring the abandoned fortress despite the warnings."
• "Narrator: Described the rain-soaked streets of the Scab district."

{{context_block}}MESSAGE TO SUMMARIZE:
{{message}}

SUMMARY:`,
    summary_injection_separator: "\n• ",
    summary_injection_template: `[STORY CONTEXT - Prior Events]
The following are condensed notes from earlier in this roleplay, provided for continuity reference.
These are NOT new messages, NOT instructions, and NOT things currently happening.
Treat this as background knowledge - reference naturally if relevant, ignore if not.
Recent chat always takes precedence over these notes.

{{summaries}}
[/STORY CONTEXT]`,
    
    // Injection settings
    injection_position: extension_prompt_types.IN_PROMPT,
    injection_depth: 4,
    injection_role: extension_prompt_roles.SYSTEM,
    
    // Per-module debug settings
    debug_truncation: false,
    debug_qdrant: false,
    debug_synergy: false,
    
    // ==================== QDRANT SETTINGS ====================
    qdrant_enabled: false,
    qdrant_url: "http://localhost:6333",
    qdrant_collection: "sillytavern_memories",
    
    // Embedding settings (local/KoboldCPP only)
    embedding_url: "",
    embedding_api_key: "",
    embedding_dimensions: null,     // Auto-detected
    
    // Memory retrieval settings
    memory_limit: 5,
    score_threshold: 0.3,
    memory_position: 3,
    retain_recent_messages: 5,
    qdrant_min_messages: 20,  // Only retrieve memories after this many messages in chat
    
    // Auto-save settings
    auto_save_memories: true,
    save_user_messages: true,
    save_char_messages: true,
    per_chat_collection: true,
    
    // ==================== SIMPLE CHUNK SETTINGS ====================
    chunk_min_size: 1200,
    chunk_max_size: 1500,
    chunk_timeout: 30000,
    
    // Per-message vectorization settings
    vectorization_delay: 2,           // Don't vectorize messages within N positions from end
    summarization_delay: 10,          // Don't summarize messages within N positions from end
    delete_on_message_delete: true,   // Delete Qdrant entries when messages are deleted
    auto_dedupe: true,                // Automatically remove duplicate entries during search
    
    // Account for Qdrant tokens in context budget
    account_qdrant_tokens: true,
};
 
// Timeout now uses get_settings('summary_endpoint_timeout') dynamically

// Global state
let TRUNCATION_INDEX = null;  // Current truncation position

// Estimation mode flag - true when char-based fallback is used instead of tokenizer
let USING_ESTIMATION_MODE = false;

// Popout state
let POPOUT_VISIBLE = false;
let POPOUT_LOCKED = false;
let $POPOUT = null;
let $DRAWER_CONTENT = null;

// Indexing state (for Qdrant)
let INDEXING_ACTIVE = false;
let INDEXING_STOPPED = false;
let INDEXING_ABORT_CONTROLLER = null;

// Calibration state machine
// States: WAITING -> INITIAL_TRAINING -> CALIBRATING -> RETRAINING -> STABLE
let CALIBRATION_STATE = 'WAITING';
let GENERATION_COUNT = 0;      // Generations in current phase
let STABLE_COUNT = 0;          // Consecutive stable generations
let LAST_CORRECTION_FACTOR = 1.0;  // Previous factor for convergence detection
let RETRAIN_COUNT = 0;         // Generations in retraining phase
let LAST_STABLE_CHAT_LENGTH = 0;  // Chat length when entering STABLE state

// V33: Cache last valid raw prompt for fallback during intercept
let CACHED_RAW_PROMPT = null;
let CACHED_RAW_PROMPT_CHAT_LENGTH = 0;

const TRAINING_GENERATIONS = 2;  // Generations needed to train correction factor (reduced from 3)
const STABLE_THRESHOLD = 5;      // Consecutive stable gens to reach STABLE state

// Qdrant token averaging for variance handling
let QDRANT_TOKEN_HISTORY = [];  // Rolling history of Qdrant injection tokens
const QDRANT_HISTORY_SIZE = 5;  // Number of samples to average

// Summary injection tracking (V22)
let DROPPED_SUMMARY_COUNT = 0;  // Summaries dropped due to token cap

// Debug summary tracking (V33)
let DEBUG_SEGMENT_COUNT = 0;
let DEBUG_MAP_HITS = 0;
let DEBUG_MAP_MISSES = 0;

// Vector Statistics State (V11)
let VECTOR_STATS = {
    // Connection health
    connected: false,
    lastConnectionError: null,

    // Collection stats (cached, refresh on demand)
    collectionName: null,
    totalPoints: 0,
    chunkPoints: 0,
    singlePoints: 0,

    // Last retrieval stats
    retrievedCount: 0,
    scores: [], // Array of scores for distribution chart
    avgScore: 0,
    minScore: 0,
    maxScore: 0,
    duplicatesRemoved: 0,

    // Buffer stats
    bufferMessageCount: 0,

    // Last update timestamps
    lastCollectionCheck: 0,
    lastRetrieval: 0
};

// Message change resilience (deletion/edit tracking)
let LAST_CHAT_LENGTH = 0;         // Track chat length to detect deletions
let LAST_CHAT_HASHES = new Map(); // Map of message index -> content hash for edit detection

// V29: Pre-snapshot state for deletion detection (fixes race condition)
let PRE_SNAPSHOT_CHAT_LENGTH = 0;
let PRE_SNAPSHOT_CHAT_HASHES = new Map();

// Utility functions
function log(...args) {
    console.log(`[${MODULE_NAME_FANCY}]`, ...args);
}

// V13: Timestamp normalization for consistent temporal filtering
function normalizeTimestamp(date) {
    // Already a valid millisecond timestamp
    if (typeof date === 'number' && date > 1000000000000) {
        return date;
    }

    // Timestamp in seconds - convert to milliseconds
    if (typeof date === 'number' && date > 1000000000 && date < 1000000000000) {
        return date * 1000;
    }

    // Date object
    if (date instanceof Date) {
        const timestamp = date.getTime();
        if (!isNaN(timestamp)) {
            return timestamp;
        }
    }

    // String date - try to parse it
    if (typeof date === 'string' && date.trim()) {
        const parsed = new Date(date);
        const timestamp = parsed.getTime();
        if (!isNaN(timestamp)) {
            return timestamp;
        }
    }

    // Fallback to current time
    debug_qdrant('Could not normalize timestamp, using current time. Input:', date);
    return Date.now();
}

// Module-specific debug functions
function debug_trunc(...args) {
    if (get_settings('debug_truncation')) {
        console.log(`[${MODULE_NAME_FANCY}][Truncation]`, ...args);
    }
}

function debug_qdrant(...args) {
    if (get_settings('debug_qdrant')) {
        console.log(`[${MODULE_NAME_FANCY}][Qdrant]`, ...args);
    }
}


// Consolidated generation summary for simplified debug output
function log_generation_summary(data) {
    if (!get_settings('debug_truncation')) return;
    
    const {
        chatLength = 0,
        oldIndex = 0,
        newIndex = 0,
        actualTokens = 0,
        targetTokens = 0,
        factor = 1.0,
        state = 'UNKNOWN',
        stableCount = 0,
        stableThreshold = 5,
        segmentCount = 0,
        mapHits = 0,
        mapMisses = 0,
        summaryCount = 0,
        summaryTokens = 0,
        droppedCount = 0,
        estimationMode = false
    } = data;
    
    const mode = estimationMode ? 'Estimation (large chat)' : 'Tokenizer';
    const indexChange = oldIndex === newIndex ? `${newIndex} (unchanged)` : `${oldIndex}→${newIndex}`;
    const tokenDiff = actualTokens - targetTokens;
    const tokenStatus = tokenDiff > 0 ? `${tokenDiff} over` : `${Math.abs(tokenDiff)} under`;
    const stateStr = state === 'STABLE' ? `${state} ✓` : `${state} (${stableCount}/${stableThreshold})`;
    
    console.log(`[${MODULE_NAME_FANCY}][Truncation] === Generation Summary ===`);
    console.log(`  Mode: ${mode} | Chat: ${chatLength} msgs | Index: ${indexChange}`);
    console.log(`  Tokens: ${actualTokens} actual → ${targetTokens} target (${tokenStatus})`);
    console.log(`  Factor: ${factor.toFixed(3)} | State: ${stateStr}`);
    console.log(`  Segments: ${segmentCount} matched | Map: ${mapHits} hits, ${mapMisses} misses`);
    console.log(`  Summaries: ${summaryCount} injected (${summaryTokens} tokens) | Dropped: ${droppedCount}`);
}

// Legacy debug function - routes to truncation debug for backward compatibility
function debug(...args) {
    if (get_settings('debug_truncation') || get_settings('debug_qdrant') || get_settings('debug_synergy')) {
        console.log(`[${MODULE_NAME_FANCY}][DEBUG]`, ...args);
    }
}

function error(...args) {
    console.error(`[${MODULE_NAME_FANCY}]`, ...args);
    toastr.error(Array.from(arguments).join(' '), MODULE_NAME_FANCY);
}

// Settings management
function initialize_settings() {
    if (!extension_settings[MODULE_NAME]) {
        log('Initializing settings...');
        extension_settings[MODULE_NAME] = structuredClone(default_settings);
    }
}

function get_settings(key) {
    return extension_settings[MODULE_NAME]?.[key] ?? default_settings[key];
}

function set_settings(key, value) {
    extension_settings[MODULE_NAME][key] = value;
    saveSettingsDebounced();
}

// Token counting with fallback for large inputs
// SillyTavern's tokenizer returns 0 for inputs > ~200K chars
const TOKENIZER_CHAR_LIMIT = 150000;  // Conservative limit

function count_tokens(text, padding = 0) {
    if (!text) return padding;
    
    const ctx = getContext();
    const textLen = text.length;
    
    // For small inputs, use tokenizer directly
    if (textLen <= TOKENIZER_CHAR_LIMIT) {
        const result = ctx.getTokenCount(text, padding);
        // Clear estimation flag when tokenizer works
        USING_ESTIMATION_MODE = false;
        return result;
    }
    
    // For large inputs, use character-based estimate
    // Average ratio is ~4 chars per token for English text
    USING_ESTIMATION_MODE = true;  // SET FLAG
    const estimate = Math.floor(textLen / 4) + padding;
    debug_trunc(`[TOKENIZER] Estimation mode: ${textLen} chars → ${estimate} tokens (4 chars/token)`);
    return estimate;
}

// Connection profile helpers removed — summarization now uses an independent OpenAI-compatible endpoint (ct_summary_endpoint_url)

// Message data management (stores summaries and flags on messages)
function set_data(message, key, value) {
    if (message?.extra?.[MODULE_NAME]?.[key] === value) return;
    
    if (!message.extra) {
        message.extra = {};
    }
    if (!message.extra[MODULE_NAME]) {
        message.extra[MODULE_NAME] = {};
    }
    
    message.extra[MODULE_NAME][key] = value;
    
    // Also save on current swipe
    let swipe_index = message.swipe_id;
    if (swipe_index && message.swipe_info?.[swipe_index]) {
        if (!message.swipe_info[swipe_index].extra) {
            message.swipe_info[swipe_index].extra = {};
        }
        message.swipe_info[swipe_index].extra[MODULE_NAME] = structuredClone(message.extra[MODULE_NAME]);
    }
}

function get_data(message, key) {
    return message?.extra?.[MODULE_NAME]?.[key];
}

function get_memory(message) {
    return get_data(message, 'memory') ?? "";
}

// Previous prompt detection
function normalize_raw_prompt(raw_prompt) {
    if (Array.isArray(raw_prompt)) {
        return raw_prompt.map(x => x.content).join('\n');
    }
    return raw_prompt;
}

function get_last_prompt_raw() {
    const ctx = getContext();
    const last_index = ctx.chat.length - 1;
    let raw_prompt = undefined;
    
    for (let i = itemizedPrompts.length - 1; i >= 0; i--) {
        let itemized_prompt = itemizedPrompts[i];
        if (itemized_prompt.mesId === last_index) {
            raw_prompt = itemized_prompt.rawPrompt;
            break;
        }
    }
    
    if (raw_prompt === undefined) {
        return undefined;
    }
    
    return normalize_raw_prompt(raw_prompt);
}

function get_previous_prompt_size() {
    let raw_prompt = get_last_prompt_raw();
    
    if (!raw_prompt) {
        debug('No previous prompt found');
        return 0;
    }
    
    const size = count_tokens(raw_prompt);
    debug(`Previous prompt size: ${size} tokens`);
    return size;
}

// Parse raw prompt into chat segments with token counts
function get_prompt_chat_segments_from_raw(raw_prompt) {
    if (!raw_prompt) {
        debug('  get_prompt_chat_segments_from_raw: No raw prompt');
        return null;
    }
    
    // Try ChatML format first: <|im_start|>role
    const chatml_regex = /<\|im_start\|>(user|assistant|system)\n/g;
    let matches = [];
    let match;
    
    // Check for ChatML format
    while ((match = chatml_regex.exec(raw_prompt)) !== null) {
        matches.push({
            index: match.index,
            role: match[1],
            format: 'chatml'
        });
    }
    
    // If no ChatML, try Llama 3 format
    if (matches.length === 0) {
        const llama3_regex = /<\|eot_id\|><\|start_header_id\|>(user|assistant|system)<\|end_header_id\|>/g;
        while ((match = llama3_regex.exec(raw_prompt)) !== null) {
            matches.push({
                index: match.index,
                role: match[1],
                format: 'llama3'
            });
        }
    }
    
    debug(`  get_prompt_chat_segments_from_raw: Found ${matches.length} header matches (format: ${matches[0]?.format || 'none'})`);
    
    if (matches.length === 0) {
        debug('  get_prompt_chat_segments_from_raw: No headers found, not Llama 3 or ChatML format');
        return null;
    }
    
    let segments = [];
    for (let i = 0; i < matches.length; i++) {
        let current = matches[i];
        let next = matches[i + 1];
        
        // Only count user and assistant messages (skip system)
        if (current.role !== 'user' && current.role !== 'assistant') {
            continue;
        }
        
        let end_index;
        if (current.format === 'chatml') {
            // ChatML ends with <|im_end|>
            const endMarker = raw_prompt.indexOf('<|im_end|>', current.index);
            end_index = endMarker !== -1 ? endMarker + 10 : (next ? next.index : raw_prompt.length);
        } else {
            // Llama 3 ends at next header or end of prompt
            end_index = next ? next.index : raw_prompt.length;
        }
        
        let segment = raw_prompt.slice(current.index, end_index);
        
        segments.push({
            role: current.role,
            tokenCount: count_tokens(segment),
        });
    }
    
    
    return segments;
}

// Build a map of message index to actual token count in prompt
function get_prompt_message_tokens_from_raw(raw_prompt, chat) {
    let segments = get_prompt_chat_segments_from_raw(raw_prompt);
    if (!segments) {
        debug('  get_prompt_message_tokens_from_raw: No segments found');
        return null;
    }
    
    debug(`  get_prompt_message_tokens_from_raw: Found ${segments.length} segments`);
    
    let map = new Map();
    let segment_index = 0;
    
    // V32 FIX: Start from truncation index (first kept message) instead of 0
    // After truncation, only the LAST N messages are in the prompt, not all messages
    const startIndex = TRUNCATION_INDEX || 0;
    
    
    // Check if all segments are the same role (completion/roleplay mode)
    const allSameRole = segments.length > 0 && segments.every(s => s.role === segments[0].role);
    if (allSameRole && segments.length > 1) {
        // Sequential mapping: map segments to non-system chat messages in order
        let segmentIdx = 0;
        for (let chatIdx = startIndex; chatIdx < chat.length && segmentIdx < segments.length; chatIdx++) {
            const msg = chat[chatIdx];
            if (msg.is_system) continue; // Skip system messages
            
            map.set(chatIdx, segments[segmentIdx].tokenCount);
            segmentIdx++;
        }
        
        return map;
    }
    
    // Match segments to chat messages
    for (let i = startIndex; i < chat.length && segment_index < segments.length; i++) {
        let message = chat[i];
        
        // Skip system messages
        if (message.is_system) {
            continue;
        }
        
        let expected_role = message.is_user ? 'user' : 'assistant';
        
        // Find next matching segment
        while (segment_index < segments.length && segments[segment_index].role !== expected_role) {
            segment_index += 1;
        }
        
        if (segment_index >= segments.length) {
            break;
        }
        
        map.set(i, segments[segment_index].tokenCount);
        segment_index += 1;
    }
    
    debug(`  get_prompt_message_tokens_from_raw: Built map with ${map.size} entries (starting from index ${startIndex})`);
    return map;
}

// Truncation index management
function load_truncation_index() {
    debug(`Loading truncation index from metadata`);
    if (chat_metadata?.[MODULE_NAME]?.truncation_index !== undefined) {
        TRUNCATION_INDEX = chat_metadata[MODULE_NAME].truncation_index;
        debug(`Loaded truncation index: ${TRUNCATION_INDEX}`);
    } else {
        // V34 BUG-002 FIX: Debug logging to verify no saved index exists
        debug(`No truncation index found in metadata`);
        debug(`  chat_metadata exists: ${!!chat_metadata}`);
        debug(`  MODULE_NAME exists in metadata: ${!!chat_metadata?.[MODULE_NAME]}`);
    }
    
    // Also load correction factor if saved (Fix 4.2: Preserve correction factor across chat switches)
    if (chat_metadata?.[MODULE_NAME]?.correction_factor !== undefined) {
        CHAT_TOKEN_CORRECTION_FACTOR = chat_metadata[MODULE_NAME].correction_factor;
        debug(`Loaded correction factor: ${CHAT_TOKEN_CORRECTION_FACTOR.toFixed(3)}`);
    }
    
    // Load calibration state for persistence across chat switches
    if (chat_metadata?.[MODULE_NAME]?.calibration_state !== undefined) {
        CALIBRATION_STATE = chat_metadata[MODULE_NAME].calibration_state;
        GENERATION_COUNT = chat_metadata[MODULE_NAME].generation_count || 0;
        STABLE_COUNT = chat_metadata[MODULE_NAME].stable_count || 0;
        RETRAIN_COUNT = chat_metadata[MODULE_NAME].retrain_count || 0;
        QDRANT_TOKEN_HISTORY = chat_metadata[MODULE_NAME].qdrant_token_history || [];
        LAST_STABLE_CHAT_LENGTH = chat_metadata[MODULE_NAME].last_stable_chat_length || 0;

        // V33 FIX: If loaded state is STABLE but LAST_STABLE_CHAT_LENGTH is 0 (legacy chat),
        // initialize it to current chat length to prevent constant recalculation
        if (CALIBRATION_STATE === 'STABLE' && LAST_STABLE_CHAT_LENGTH === 0) {
            const currentChatLength = getContext().chat?.length || 0;
            LAST_STABLE_CHAT_LENGTH = currentChatLength;
            debug(`Fixed legacy STABLE state: initialized LAST_STABLE_CHAT_LENGTH to ${currentChatLength}`);
        }

        debug(`Loaded calibration state: ${CALIBRATION_STATE}, stable: ${STABLE_COUNT}/${STABLE_THRESHOLD}`);
    } else {
        // V32 FIX: If correction_factor was loaded but calibration_state wasn't,
        // this is an older chat that learned a factor before state was persisted.
        // Set to CALIBRATING instead of WAITING to preserve the learned factor.
        const hasLearnedFactor = CHAT_TOKEN_CORRECTION_FACTOR !== 1.0;
        if (hasLearnedFactor) {
            CALIBRATION_STATE = 'CALIBRATING';
            GENERATION_COUNT = 0;
            STABLE_COUNT = 3;  // Assume some stability since factor was learned
            debug(`No calibration state but has learned factor (${CHAT_TOKEN_CORRECTION_FACTOR.toFixed(3)}), starting in CALIBRATING`);
        } else {
            CALIBRATION_STATE = 'WAITING';
            GENERATION_COUNT = 0;
            STABLE_COUNT = 0;
            debug(`No calibration state found, reset to WAITING`);
        }
        RETRAIN_COUNT = 0;
        QDRANT_TOKEN_HISTORY = [];
    }
}

function save_truncation_index() {
    if (!chat_metadata[MODULE_NAME]) {
        chat_metadata[MODULE_NAME] = {};
    }
    chat_metadata[MODULE_NAME].truncation_index = TRUNCATION_INDEX;
    chat_metadata[MODULE_NAME].target_size = get_settings('target_context_size');
    chat_metadata[MODULE_NAME].correction_factor = CHAT_TOKEN_CORRECTION_FACTOR;
    
    // Save calibration state for persistence across chat switches
    chat_metadata[MODULE_NAME].calibration_state = CALIBRATION_STATE;
    chat_metadata[MODULE_NAME].generation_count = GENERATION_COUNT;
    chat_metadata[MODULE_NAME].stable_count = STABLE_COUNT;
    chat_metadata[MODULE_NAME].retrain_count = RETRAIN_COUNT;
    chat_metadata[MODULE_NAME].qdrant_token_history = QDRANT_TOKEN_HISTORY;
    chat_metadata[MODULE_NAME].last_stable_chat_length = LAST_STABLE_CHAT_LENGTH;

    debug(`Saved truncation index: ${TRUNCATION_INDEX}, correction factor: ${CHAT_TOKEN_CORRECTION_FACTOR.toFixed(3)}, state: ${CALIBRATION_STATE}`);
    saveMetadataDebounced();
}

function reset_truncation_index() {
    debug('Resetting truncation index');
    TRUNCATION_INDEX = null;
    // NOTE: We intentionally do NOT reset CHAT_TOKEN_CORRECTION_FACTOR here
    // The correction factor is learned over time and should persist across
    // target size changes to maintain calibration stability
    save_truncation_index();
}

// ==================== MESSAGE CHANGE RESILIENCE ====================

// Compute a hash for message content (for edit detection)
function compute_message_hash(message) {
    if (!message || !message.mes) return null;
    return getStringHash(message.mes);
}

// Take a snapshot of current chat state for change detection
function snapshot_chat_state() {
    const ctx = getContext();
    const chat = ctx.chat;
    
    // V29 FIX: Preserve pre-snapshot state for deletion detection (fixes race condition)
    PRE_SNAPSHOT_CHAT_LENGTH = LAST_CHAT_LENGTH;
    PRE_SNAPSHOT_CHAT_HASHES = new Map(LAST_CHAT_HASHES);
    
    if (!chat) {
        LAST_CHAT_LENGTH = 0;
        LAST_CHAT_HASHES.clear();
        return;
    }
    
    LAST_CHAT_LENGTH = chat.length;
    LAST_CHAT_HASHES.clear();
    
    for (let i = 0; i < chat.length; i++) {
        const hash = compute_message_hash(chat[i]);
        if (hash) {
            LAST_CHAT_HASHES.set(i, hash);
        }
    }
    
    debug_trunc(`Snapshot taken: ${chat.length} messages, ${LAST_CHAT_HASHES.size} hashes`);
}

// Handle message deletion with smart truncation adjustment
function handle_message_deleted() {
    const ctx = getContext();
    const chat = ctx.chat;
    const currentLength = chat ? chat.length : 0;
    
    // BUG-002 FIX: Use LAST_CHAT_LENGTH (stable snapshot before this event)
    const deletedCount = LAST_CHAT_LENGTH - currentLength;
    
    if (deletedCount <= 0) {
        // No deletion detected or chat grew
        LAST_CHAT_LENGTH = currentLength;
        return;
    }
    
    debug_trunc(`═══ MESSAGE DELETION DETECTED ═══`);
    debug_trunc(`  Deleted: ${deletedCount} message(s)`);
    debug_trunc(`  Previous length: ${LAST_CHAT_LENGTH}, Current: ${currentLength}`);
    
    // Determine deletion location relative to truncation index
    let deletionsBeforeTruncation = 0;
    let deletionsAfterTruncation = 0;
    
    if (TRUNCATION_INDEX !== null && TRUNCATION_INDEX > 0) {
        // V29 FIX: Detect where deletions occurred using PRE_SNAPSHOT hash (before CHAT_CHANGED)
        const oldHash = PRE_SNAPSHOT_CHAT_HASHES.get(TRUNCATION_INDEX);
        const newMessage = chat[TRUNCATION_INDEX];
        const newHash = newMessage ? compute_message_hash(newMessage) : null;
        
        if (TRUNCATION_INDEX >= currentLength) {
            // Truncation index is beyond current chat = deletions were before/at it
            deletionsBeforeTruncation = deletedCount;
            TRUNCATION_INDEX = Math.max(0, currentLength - 1);
            debug_trunc(`  Truncation index adjusted to ${TRUNCATION_INDEX} (beyond chat)`);
        } else if (oldHash && newHash && oldHash !== newHash) {
            // Message at truncation point changed = deletion was before it
            deletionsBeforeTruncation = deletedCount;
            TRUNCATION_INDEX = Math.max(0, TRUNCATION_INDEX - deletedCount);
            debug_trunc(`  Truncation index adjusted to ${TRUNCATION_INDEX} (hash mismatch)`);
        } else {
            // Hash at truncation point is same = deletions were after it
            deletionsAfterTruncation = deletedCount;
            debug_trunc(`  Deletions were after truncation point - no index adjustment`);
        }
    } else {
        // No truncation yet, all deletions are "after" (in recent context)
        deletionsAfterTruncation = deletedCount;
    }
    
    debug_trunc(`  Deletions before truncation: ${deletionsBeforeTruncation}`);
    debug_trunc(`  Deletions after truncation: ${deletionsAfterTruncation}`);
    
    // Save updated truncation index
    save_truncation_index();
    
    // Update snapshot
    snapshot_chat_state();

    // Refresh memory
    refresh_memory();

    // Update chat length tracking (FIX: ensure this always runs)
    LAST_CHAT_LENGTH = currentLength;

    debug_trunc(`═══════════════════════════════`);
}


// Detect message edits by comparing hashes
function detect_message_edits() {
    const ctx = getContext();
    const chat = ctx.chat;
    
    if (!chat) return;
    
    let editCount = 0;
    
    for (let i = 0; i < Math.min(chat.length, LAST_CHAT_LENGTH); i++) {
        const oldHash = LAST_CHAT_HASHES.get(i);
        const newHash = compute_message_hash(chat[i]);
        
        if (oldHash && newHash && oldHash !== newHash) {
            editCount++;
            debug_trunc(`Edit detected at message ${i}`);
            
            // Mark summary as stale if message was lagging (excluded from context)
            const message = chat[i];
            if (get_data(message, 'lagging') && get_memory(message)) {
                set_data(message, 'needs_summary', true);
                debug_trunc(`Marked message ${i} for re-summarization`);
            }
        }
    }
    
    if (editCount > 0) {
        debug_trunc(`Total edits detected: ${editCount}`);
    }
    
    // Update snapshot after detection
    snapshot_chat_state();
}


function should_recalculate_truncation() {
    // Recalculate if target size changed
    const savedTargetSize = chat_metadata?.[MODULE_NAME]?.target_size;
    const currentTargetSize = get_settings('target_context_size');
    
    if (savedTargetSize !== undefined && savedTargetSize !== currentTargetSize) {
        debug(`Target size changed from ${savedTargetSize} to ${currentTargetSize}, forcing recalculation`);
        return true;
    }
    
    // V35 FIX: Remove correction factor change detection here
    // The factor is loaded in load_truncation_index() which is called before this,
    // so comparing against the module-level variable is correct now.
    // But we should NOT trigger recalculation just because factor changed -
    // factor changes are continuous and expected during calibration.
    // Only target size changes should force full recalculation.
    
    return false;
}

// Calculate truncation index based on target context size
// Based on MessageSummarize's get_injection_threshold() token-based calculation
function calculate_truncation_index() {
    const ctx = getContext();
    const chat = ctx.chat;
    let targetSize = get_settings('target_context_size');

    const batchSize = get_settings('batch_size');
    const minKeep = get_settings('min_messages_to_keep');
    const maxContext = getMaxContextSize();

    // V33: Defensive cap - never exceed 90% of max context regardless of settings
    const maxSafeContext = Math.floor(maxContext * 0.90);
    if (targetSize > maxSafeContext) {
        debug_trunc(`Target ${targetSize} exceeds safe limit, capping to ${maxSafeContext}`);
        targetSize = maxSafeContext;
    }
    
    
    // SYNERGY: Account for Qdrant tokens in target size
    if (get_settings('qdrant_enabled') && get_settings('account_qdrant_tokens')) {
        const qdrantTokens = get_qdrant_injection_tokens();
        if (qdrantTokens > 0) {
            targetSize = targetSize - qdrantTokens;
        }
    }
    
    // Use current context size from intercept
    const currentPromptSize = CURRENT_CONTEXT_SIZE;
    
    if (currentPromptSize === 0) {
        debug_trunc('No context size available, cannot calculate truncation');
        debug_trunc(`═══ TRUNCATION CALCULATION END (no data) ═══`);
        return 0;
    }
    
    
    // Check if we're under target
    if (currentPromptSize <= targetSize) {
        // If no truncation is currently active, return 0
        if (!TRUNCATION_INDEX || TRUNCATION_INDEX === 0) {
            debug_trunc('Under target with no active truncation, returning 0');
            return 0;
        }
        
        // We're under target but have truncation - we should try to REDUCE it
        // to include more messages and better utilize the context budget
        debug_trunc(`Under target (${currentPromptSize} <= ${targetSize}) but truncation active (${TRUNCATION_INDEX})`);
        debug_trunc('Will attempt to reduce truncation to include more messages...');
        
        // Fall through to the rest of the function which will try to optimize
    }
    
    // Get the current truncation index (or start at 0)
    let currentIndex = TRUNCATION_INDEX || 0;
    let maxIndex = Math.max(chat.length - minKeep, 0);
    
    // V32 FIX: Also limit to keeping at least 10% of messages (never truncate more than 90%)
    // This prevents pathological cases where correction factor collapse causes massive over-truncation
    const percentageMinKeep = Math.floor(chat.length * 0.10);
    maxIndex = Math.min(maxIndex, chat.length - percentageMinKeep);
    debug_trunc(`  Max index (with 10% floor): ${maxIndex} (keeps at least ${percentageMinKeep} messages)`);
    
    let nextIndex = Math.min(currentIndex, maxIndex);
    
    // Calculate separator size for summaries
    const sepSize = calculate_injection_separator_size();
    
    // Prompt header tokens (for estimating message sizes in prompt)
    const PROMPT_HEADER_USER = '<|eot_id|><|start_header_id|>user<|end_header_id|>';
    const PROMPT_HEADER_ASSISTANT = '<|eot_id|><|start_header_id|>assistant<|end_header_id|>';
    const promptHeaderTokens = {
        user: count_tokens(PROMPT_HEADER_USER),
        assistant: count_tokens(PROMPT_HEADER_ASSISTANT),
    };
    
    // Build message token map from last prompt for accurate estimation
    let last_raw_prompt = get_last_prompt_raw();

    // V33: Fallback to cached raw prompt if unavailable but chat length matches
    if (!last_raw_prompt) {
        const currentChatLength = getContext().chat?.length || 0;
        if (CACHED_RAW_PROMPT && CACHED_RAW_PROMPT_CHAT_LENGTH === currentChatLength) {
            last_raw_prompt = CACHED_RAW_PROMPT;
            debug_trunc(`Using cached raw prompt for fallback (${last_raw_prompt.length} chars, chat length: ${currentChatLength})`);
        } else {
            debug_trunc(`No cached prompt or chat length mismatch (${CACHED_RAW_PROMPT_CHAT_LENGTH} vs ${currentChatLength})`);
        }
    }

    let message_token_map = get_prompt_message_tokens_from_raw(last_raw_prompt, chat);
    
    // Calculate non-chat budget from the current raw prompt
    // Both total and chat tokens must come from the SAME prompt for accuracy
    let totalPromptTokens;
    let promptChatTokens = 0;
    let nonChatBudget;
    
    
    if (!last_raw_prompt) {
        // V33: Use learned ratio from previous generations (more accurate than fixed 40%)
        nonChatBudget = Math.floor(currentPromptSize * LAST_KNOWN_NON_CHAT_RATIO);
        debug_trunc(`  No raw prompt available - using ${LAST_KNOWN_NON_CHAT_RATIO * 100}% learned ratio`);
        debug_trunc(`  Non-chat budget (estimated): ${nonChatBudget} tokens`);
    } else {
        // Have raw prompt - calculate accurately
        totalPromptTokens = count_tokens(last_raw_prompt);
        
        let segments = get_prompt_chat_segments_from_raw(last_raw_prompt);
        if (segments && segments.length > 0) {
            promptChatTokens = segments.reduce((sum, seg) => sum + seg.tokenCount, 0);
            DEBUG_SEGMENT_COUNT = segments.length;
        }
        
        // V35 FIX: Do NOT apply correction factor to non-chat budget
        // Non-chat (system prompt, etc.) is measured directly from raw prompt and is accurate
        // Only CHAT token estimates need correction (they're calculated, not measured)
        const rawNonChatBudget = Math.max(totalPromptTokens - promptChatTokens, 0);
        nonChatBudget = rawNonChatBudget;  // Use raw value directly
        
    }
    
    // Track token map usage
    let map_hits = 0;
    let map_misses = 0;
    
    // Function to estimate message tokens in prompt
    function estimateMessagePromptTokens(message, index) {
        // Try to use actual token count from map first
        if (message_token_map) {
            let mapped = message_token_map.get(index);
            if (mapped !== undefined) {
                map_hits++;
                DEBUG_MAP_HITS++;
                return mapped;
            }
        }
        
        // Fall back to estimation
        map_misses++;
        DEBUG_MAP_MISSES++;
        const roleHeaderTokens = message.is_user ? promptHeaderTokens.user : promptHeaderTokens.assistant;
        return count_tokens(message.mes) + roleHeaderTokens;
    }
    
    // Function to estimate total chat size with given truncation index
    function estimateChatSize(startIndex) {
        let total = 0;
        for (let i = 0; i < chat.length; i++) {
            const message = chat[i];
            
            // Skip system messages
            if (message.is_system) continue;
            
            // Messages before startIndex are excluded (lagging)
            // Messages at or after startIndex are kept in full
            const lagging = i < startIndex;
            if (!lagging) {
                // Kept message - use full token count
                // V32 FIX: Token map values are already accurate from prompt parsing
                // Only apply correction factor to fallback estimates (map misses)
                const mapValue = message_token_map ? message_token_map.get(i) : undefined;
                if (mapValue !== undefined) {
                    total += mapValue;  // Token map values are already accurate
                } else {
                    // Fall back to estimation with correction factor
                    const rawEstimate = estimateMessagePromptTokens(message, i);
                    total += Math.floor(rawEstimate * CHAT_TOKEN_CORRECTION_FACTOR);
                }
                continue;
            }
            
            // V33 FIX: Do NOT add summary tokens for lagging messages!
            // Summaries are injected via setExtensionPrompt() and counted in nonChatBudget.
            // Adding them here caused double-counting and ~35% over-estimation.
            // Lagging messages simply don't contribute to chat token count.
        }
        return total;
    }
    
    // V29: Estimate chat size WITHOUT correction factor (for accurate factor calculation)
    function estimateChatSizeRaw(startIndex) {
        let total = 0;
        for (let i = 0; i < chat.length; i++) {
            const message = chat[i];
            
            // Skip system messages
            if (message.is_system) continue;
            
            // Messages before startIndex are excluded (lagging)
            // Messages at or after startIndex are kept in full
            const lagging = i < startIndex;
            if (!lagging) {
                // Kept message - use RAW token count (no correction factor)
                const rawEstimate = estimateMessagePromptTokens(message, i);
                total += rawEstimate;  // V29: No correction factor applied
                continue;
            }
            
            // V33 FIX: Same as estimateChatSize() - no summary tokens for lagging messages
        }
        return total;
    }
    
    // Current chat size
    let currentChatSize = estimateChatSize(currentIndex);
    
    
    // If we're over target, truncate in batches
    if (currentChatSize + nonChatBudget > targetSize) {
        while (currentChatSize + nonChatBudget > targetSize && nextIndex < maxIndex) {
            let stepEnd = nextIndex;
            
            // Calculate batch end
            if (batchSize > 0) {
                stepEnd = Math.min(nextIndex + batchSize, maxIndex);
            }
            
            // Estimate chat size after this batch
            const candidateChatSize = estimateChatSize(stepEnd);
            
            // If this gets us under target, we're done
            if (candidateChatSize + nonChatBudget <= targetSize) {
                // Try to find exact message that gets us under
                for (let i = nextIndex; i < stepEnd; i++) {
                    const partialSize = estimateChatSize(i + 1);
                    if (partialSize + nonChatBudget <= targetSize) {
                        nextIndex = i + 1;
                        currentChatSize = partialSize;
                        break;
                    }
                    nextIndex = i + 1;
                    currentChatSize = partialSize;
                }
                break;
            }
            
            // Still over target, continue
            currentChatSize = candidateChatSize;
            nextIndex = stepEnd;
        }
    }
    
    // V26/V27: If we're under target AND have truncation, try to REDUCE it
    // This recovers context space when summaries are smaller than originals
    let finalIndex = Math.max(nextIndex, currentIndex);
    
    // Check if we have room to include more messages
    const currentTotal = estimateChatSize(finalIndex) + nonChatBudget;
    const underTarget = currentTotal < targetSize;
    const hasHeadroom = targetSize - currentTotal;
    
    
    if (underTarget && finalIndex > 0) {
        // Greedily include more messages while under target
        let reducedIndex = finalIndex;
        let iterations = 0;
        const MAX_ITERATIONS = 50;  // Safety limit
        
        while (reducedIndex > 0 && iterations < MAX_ITERATIONS) {
            iterations++;
            
            // Get info about the message we're considering including
            const candidateIdx = reducedIndex - 1;
            const msg = chat[candidateIdx];
            
            if (!msg || msg.is_system) {
                reducedIndex--;
                continue;
            }
            
            // Calculate size if we include this message
            const candidateSize = estimateChatSize(candidateIdx);
            const candidateTotal = candidateSize + nonChatBudget;
            
            if (candidateTotal <= targetSize) {
                reducedIndex--;
            } else {
                break;
            }
        }
        
        if (reducedIndex < finalIndex) {
            finalIndex = reducedIndex;
        }
    }
    
    const predictedChatSize = estimateChatSize(finalIndex);
    const predictedChatSizeRaw = estimateChatSizeRaw(finalIndex);  // V29: Raw prediction for factor calculation
    const predictedTotal = predictedChatSize + nonChatBudget;
    
    
    // Store predictions for comparison with actual results
    LAST_PREDICTED_SIZE = predictedTotal;
    LAST_PREDICTED_CHAT_SIZE = predictedChatSize;
    LAST_PREDICTED_CHAT_SIZE_RAW = predictedChatSizeRaw;  // V29: Store raw for correction factor calculation
    LAST_PREDICTED_NON_CHAT_SIZE = nonChatBudget;
    
    return finalIndex;
}

// Helper function to calculate separator size
function calculate_injection_separator_size(separator = null) {
    if (separator === null) separator = get_settings('summary_injection_separator');
    const text = "This is a test.";
    const t1 = count_tokens(text);
    const t2 = count_tokens(text + separator + text);
    return t2 - (2 * t1);
}

// Helper function to check message exclusion
function check_message_exclusion(message) {
    if (!message) return false;
    if (get_data(message, 'remember')) return true;
    if (get_data(message, 'exclude')) return false;
    if (!get_settings('include_user_messages') && message.is_user) return false;
    if (message.is_thoughts) return false;
    if (!get_settings('include_system_messages') && message.is_system) return false;
    const tokenSize = count_tokens(message.mes);
    if (tokenSize < get_settings('message_length_threshold')) return false;
    return true;
}

// Update message inclusion flags (determines which messages to keep/exclude)
function update_message_inclusion_flags() {
    const ctx = getContext();
    const chat = ctx.chat;
    
    debug("Updating message inclusion flags");
    
    // Load truncation index
    if (TRUNCATION_INDEX === null) {
        load_truncation_index();
    }
    
    // Force recalculation if target size changed
    if (should_recalculate_truncation()) {
        debug('Forcing recalculation due to settings change');
        TRUNCATION_INDEX = null;
    }
    
    // V33 BUG-002 FIX: In STABLE state, only recalculate if new messages were added
    const chatLength = ctx.chat?.length || 0;

    // V34 FIX: Lock index during CALIBRATING and RETRAINING states
    // Only allow recalculation in WAITING, INITIAL_TRAINING, or STABLE states
    const lockIndex = CALIBRATION_STATE === 'CALIBRATING' || CALIBRATION_STATE === 'RETRAINING';

    if (lockIndex) {
        if (TRUNCATION_INDEX !== null) {
            // V33: Robust index locking - use actual kept message count, not chat length delta
            const keptMessages = chatLength - TRUNCATION_INDEX;
            const batchSize = get_settings('batch_size');
            const minKeep = get_settings('min_messages_to_keep');

            // Only trim if we'd still keep minimum messages
            if (keptMessages > minKeep + batchSize) {
                // Check if we need a batch trim based on context overflow
                // Use the ACTUAL context size from last generation, not estimate
                const targetSize = get_settings('target_context_size');
                if (LAST_ACTUAL_PROMPT_SIZE > targetSize * 1.10) {  // 10% over target
                    TRUNCATION_INDEX = TRUNCATION_INDEX + batchSize;
                    LAST_STABLE_CHAT_LENGTH = chatLength;
                    debug_trunc(`LOCKED: Batch trim triggered (10% over target), index ${TRUNCATION_INDEX - batchSize}→${TRUNCATION_INDEX}`);
                } else {
                    debug_trunc(`LOCKED: Index stays at ${TRUNCATION_INDEX} (under 10% threshold)`);
                }
            } else {
                debug_trunc(`LOCKED: Index stays at ${TRUNCATION_INDEX} (would exceed minKeep)`);
            }
        } else {
            // Locked but no index yet - don't recalculate during calibration
            debug_trunc(`LOCKED: No index yet during ${CALIBRATION_STATE}, skipping recalculation`);
        }
    } else if (CALIBRATION_STATE === 'STABLE' && LAST_STABLE_CHAT_LENGTH > 0) {
        const newMessages = chatLength - LAST_STABLE_CHAT_LENGTH;

        if (newMessages <= 0) {
            // No new messages - keep cached truncation index for cache stability
            debug_trunc(`STABLE: No new messages, keeping TRUNCATION_INDEX at ${TRUNCATION_INDEX}`);
        } else {
            // New messages added - recalculate and update tracking
            debug_trunc(`STABLE: ${newMessages} new message(s), recalculating truncation`);
            TRUNCATION_INDEX = calculate_truncation_index();
            LAST_STABLE_CHAT_LENGTH = chatLength;
        }
    } else {
        // Not locked and not in STABLE - recalculate (WAITING or INITIAL_TRAINING)
        TRUNCATION_INDEX = calculate_truncation_index();
        // Set LAST_STABLE_CHAT_LENGTH when we first calculate the index
        if (TRUNCATION_INDEX !== null && TRUNCATION_INDEX > 0) {
            LAST_STABLE_CHAT_LENGTH = chatLength;
            debug_trunc(`Initial index set to ${TRUNCATION_INDEX}, tracking ${chatLength} messages`);
        }
        save_truncation_index();
    }
    
    // Sanity check: ensure truncation index doesn't exceed chat length
    if (TRUNCATION_INDEX > chat.length) {
        debug_trunc(`WARNING: TRUNCATION_INDEX (${TRUNCATION_INDEX}) exceeds chat length (${chat.length}), capping to chat length`);
        TRUNCATION_INDEX = chat.length;
        save_truncation_index();
    }
    
    debug(`Truncation index: ${TRUNCATION_INDEX}`);
    
    // Mark messages as lagging (excluded) or not
    // lagging = true means the message is BEFORE the threshold (excluded from context, "lagging behind")
    // lagging = false means the message is AT OR AFTER the threshold (kept in context)
    for (let i = 0; i < chat.length; i++) {
        const lagging = i < TRUNCATION_INDEX;
        set_data(chat[i], 'lagging', lagging);
        
        // If lagging (excluded) and has no summary, mark for summarization
        if (lagging && !get_memory(chat[i]) && !chat[i].is_system) {
            set_data(chat[i], 'needs_summary', true);
        }
    }
}

// Concatenate summaries
function concatenate_summaries(indexes) {
    const ctx = getContext();
    const chat = ctx.chat;
    const separator = get_settings('summary_injection_separator');
    
    let summary = "";
    for (let i of indexes) {
        const memory = get_memory(chat[i]);
        if (memory) {
            summary += separator + memory;
        }
    }
    
    return summary;
}

// Calculate effective max summary injection tokens (auto or manual) - V22
function get_max_summary_injection_tokens() {
    if (get_settings('auto_limit_summaries')) {
        // Auto-calculate: 20% of target budget
        const maxContext = getMaxContextSize();
        const targetUtilization = get_settings('target_utilization') || 0.80;
        return Math.floor(maxContext * targetUtilization * 0.20);
    }
    // Manual: use setting directly (0 = unlimited)
    return get_settings('max_summary_injection_tokens') || 0;
}

// Collect messages that need summaries injected (V22: respects token cap)
function collect_summary_indexes() {
    const ctx = getContext();
    const chat = ctx.chat;
    const maxTokens = get_max_summary_injection_tokens();
    const separator = get_settings('summary_injection_separator');
    const sepSize = calculate_injection_separator_size(separator);
    
    const indexes = [];
    let totalTokens = 0;
    let droppedCount = 0;
    
    // Iterate from NEWEST to OLDEST (most recent summaries have priority)
    for (let i = chat.length - 1; i >= 0; i--) {
        const lagging = get_data(chat[i], 'lagging');
        const memory = get_memory(chat[i]);
        
        if (lagging && memory) {
            const memoryTokens = count_tokens(memory) + sepSize;
            
            // Check if adding this summary would exceed cap
            if (maxTokens > 0 && totalTokens + memoryTokens > maxTokens) {
                droppedCount++;
                continue;  // Skip this summary (dropped)
            }
            
            indexes.unshift(i);  // Add to front to maintain chronological order
            totalTokens += memoryTokens;
        }
    }
    
    // Store dropped count for dashboard display
    DROPPED_SUMMARY_COUNT = droppedCount;
    
    debug_trunc(`Summary injection: ${indexes.length} included, ${droppedCount} dropped (${totalTokens}/${maxTokens} tokens)`);
    
    return indexes;
}

// Get summary injection text
function get_summary_injection() {
    const indexes = collect_summary_indexes();
    
    if (indexes.length === 0) {
        return "";
    }
    
    const summaries = concatenate_summaries(indexes);
    const template = get_settings('summary_injection_template');
    
    return template.replace('{{summaries}}', summaries);
}

// Refresh memory state (called before generation)
function refresh_memory() {
    const ctx = getContext();
    
    if (!get_settings('enabled')) {
        ctx.setExtensionPrompt(`${MODULE_NAME}_summaries`, "");
        return;
    }
    
    debug_trunc("Refreshing memory");
    
    // Update which messages to keep/exclude
    update_message_inclusion_flags();
    
    // Get summary injection text
    const injection = get_summary_injection();
    const summaryIndexes = collect_summary_indexes();
    const summaryTokens = injection ? count_tokens(injection) : 0;
    
    // Log summary injection details
    if (summaryIndexes.length > 0) {
        debug_trunc(`═══ SUMMARY INJECTION ═══`);
        debug_trunc(`  Messages with summaries: ${summaryIndexes.length}`);
        debug_trunc(`  Lagging messages: ${TRUNCATION_INDEX || 0}`);
        debug_trunc(`  Summary tokens: ${summaryTokens}`);
        debug_trunc(`  Injection depth: ${get_settings('injection_depth')}`);
        debug_trunc(`═════════════════════════`);
    }
    
    // Inject summaries
    ctx.setExtensionPrompt(
        `${MODULE_NAME}_summaries`,
        injection,
        get_settings('injection_position'),
        get_settings('injection_depth'),
        false,
        get_settings('injection_role')
    );
    
    debug_trunc(`Injected ${summaryIndexes.length} summaries (${summaryTokens} tokens)`);
}

// Global variable to store context size from intercept
let CURRENT_CONTEXT_SIZE = 0;
let LAST_ACTUAL_PROMPT_SIZE = 0;
let LAST_PREDICTED_SIZE = 0;
let LAST_PREDICTED_CHAT_SIZE = 0;
let LAST_PREDICTED_CHAT_SIZE_RAW = 0;  // V29: Uncorrected value for factor calculation
let LAST_PREDICTED_NON_CHAT_SIZE = 0;
let LAST_KNOWN_NON_CHAT_RATIO = 0.40;  // V33: Learned ratio, starts at 40%

// Cache for valid Overview tab data to prevent wild utilization swings
let LAST_VALID_UTILIZATION = null;
let LAST_VALID_MAX_CONTEXT = null;

// Adaptive correction factor (learned from previous generations)
let CHAT_TOKEN_CORRECTION_FACTOR = 1.0;  // Multiplier for chat token estimates

// Message interception hook (called by SillyTavern before generation)
// Note: This is now an async function for Qdrant support
globalThis.truncator_intercept_messages = async function (chat, contextSize, abort, type) {
    if (!get_settings('enabled') && !get_settings('qdrant_enabled')) return;
    
    // Store context size for calculation
    CURRENT_CONTEXT_SIZE = contextSize;
    
    // Refresh Qdrant memories first (async) - if enabled
    if (get_settings('qdrant_enabled')) {
        try {
            await refresh_qdrant_memories();
        } catch (e) {
            error('Failed to refresh Qdrant memories:', e);
        }
    }
    
    // Refresh memory state (calculates truncation, sets flags)
    if (get_settings('enabled')) {
        refresh_memory();
    }
    
    debug(`Intercepting messages. Type: ${type}, Context: ${contextSize}`);
    
    // Determine which messages to process
    let start = chat.length - 1;
    if (type === 'continue') start--;
    
    // Get IGNORE_SYMBOL
    let IGNORE_SYMBOL = getContext().symbols.ignore;
    
    // Mark messages with IGNORE_SYMBOL based on lagging flag
    // lagging = true means excluded (IGNORE_SYMBOL = true)
    // lagging = false means kept (IGNORE_SYMBOL = false)
    let kept_count = 0;
    let excluded_count = 0;
    for (let i = start; i >= 0; i--) {
        // Ensure extra exists before trying to delete properties
        if (chat[i].extra) {
            delete chat[i].extra.ignore_formatting;
        }
        
        let message = chat[i];
        let lagging = get_data(message, 'lagging');
        
        chat[i] = structuredClone(chat[i]);
        
        // Ensure extra exists after cloning
        if (!chat[i].extra) {
            chat[i].extra = {};
        }
        
        chat[i].extra[IGNORE_SYMBOL] = lagging;
        
        if (lagging) {
            excluded_count++;
        } else {
            kept_count++;
        }
    }
    
    debug(`Applied IGNORE_SYMBOL: ${kept_count} kept, ${excluded_count} excluded`);
};

// Update status display after generation
function update_status_display() {
    debug('update_status_display called');
    const $display = $('#ct_status_display');
    const $text = $('#ct_status_text');
    
    debug(`  $display found: ${$display.length > 0}`);
    debug(`  $text found: ${$text.length > 0}`);
    
    // Get the last prompt size
    const last_raw_prompt = get_last_prompt_raw();
    debug(`  last_raw_prompt exists: ${!!last_raw_prompt}`);

    // V33: Cache valid raw prompt for fallback during calculate_truncation_index
    if (last_raw_prompt) {
        CACHED_RAW_PROMPT = last_raw_prompt;
        CACHED_RAW_PROMPT_CHAT_LENGTH = getContext().chat?.length || 0;
        debug_trunc(`Cached raw prompt (${last_raw_prompt.length} chars) for fallback`);
    }

    if (!last_raw_prompt) {
        $display.hide();
        debug('  No raw prompt, hiding display');
        return;
    }
    
    let actualSize = count_tokens(last_raw_prompt);
    const targetSize = get_settings('target_context_size');
    
    // Safety: If tokenizer returned 0, try segment-based calculation
    if (actualSize === 0 && last_raw_prompt && last_raw_prompt.length > 0) {
        const segments = get_prompt_chat_segments_from_raw(last_raw_prompt);
        if (segments && segments.length > 0) {
            actualSize = segments.reduce((sum, seg) => sum + seg.tokenCount, 0);
            debug(`[TOKENIZER] Used segment sum: ${actualSize} tokens from ${segments.length} segments`);
        } else {
            // Ultimate fallback: character-based estimate
            actualSize = Math.floor(last_raw_prompt.length / 4);
            debug(`[TOKENIZER] Used char estimate: ${actualSize} tokens`);
        }
    }
    
    const difference = actualSize - targetSize;
    const percentError = targetSize > 0 ? Math.abs((difference / targetSize) * 100) : 0;
    
    // Calculate and apply adaptive correction factor
    // V33: Skip factor update in STABLE, or when prediction is already very accurate (<1% error)
    const predictionError = Math.abs(actualSize - LAST_PREDICTED_SIZE) / LAST_PREDICTED_SIZE;
    const skipFactorUpdate = CALIBRATION_STATE === 'STABLE' || predictionError < 0.01;

    // V34 FIX: Skip factor update entirely if no raw prompt
    // This prevents estimation-based index jumps
    if (!last_raw_prompt) {
        debug_trunc('No raw prompt available - skipping factor update to preserve stability');
        // Still update the memory display and overview
        update_memory_display();
        update_overview_tab();
        return;
    }

    if (LAST_PREDICTED_SIZE > 0 && LAST_PREDICTED_CHAT_SIZE > 0 && !skipFactorUpdate) {
        // Analyze actual chat vs non-chat from current prompt
        const segments = get_prompt_chat_segments_from_raw(last_raw_prompt);
        const actualChatTokens = segments ? segments.reduce((sum, seg) => sum + seg.tokenCount, 0) : 0;
        const actualNonChatTokens = actualSize - actualChatTokens;
        
        // V29 FIX: Calculate correction factor using RAW prediction (not corrected)
        // This breaks the feedback loop where corrected predictions caused factor convergence to sqrt(target)
        const newCorrectionFactor = actualChatTokens / LAST_PREDICTED_CHAT_SIZE_RAW;
        const oldCorrectionFactor = CHAT_TOKEN_CORRECTION_FACTOR;
        
        // V33: Use higher weight on first measurement (faster initial convergence)
        const predictedChat = LAST_PREDICTED_CHAT_SIZE;
        const errorPercent = Math.abs(predictedChat - actualChatTokens) / actualChatTokens;
        const isFirstMeasurement = GENERATION_COUNT === 1 && CALIBRATION_STATE === 'INITIAL_TRAINING';
        const newWeight = isFirstMeasurement ? 0.80 : (errorPercent > 0.20 ? 0.60 : 0.40);
        
        // Smooth the correction factor using adaptive weight
        CHAT_TOKEN_CORRECTION_FACTOR = (newWeight * newCorrectionFactor) + ((1 - newWeight) * oldCorrectionFactor);
        
        debug_trunc(`  Smoothing weight: ${newWeight} (error: ${(errorPercent * 100).toFixed(1)}%)`);
        
        // V32 FIX: Clamp correction factor to prevent runaway deviation
        // Lower bound relaxed from 0.7 to 0.5 to handle edge cases
        const MIN_CORRECTION_FACTOR = 0.5;
        const MAX_CORRECTION_FACTOR = 1.5;
        CHAT_TOKEN_CORRECTION_FACTOR = Math.max(MIN_CORRECTION_FACTOR, Math.min(MAX_CORRECTION_FACTOR, CHAT_TOKEN_CORRECTION_FACTOR));
        
        debug_trunc(`  Bounded factor: ${CHAT_TOKEN_CORRECTION_FACTOR.toFixed(3)} (min: ${MIN_CORRECTION_FACTOR}, max: ${MAX_CORRECTION_FACTOR})`);
        
        // Log correction factor updates (simplified)
        debug_trunc(`Factor Update: ${oldCorrectionFactor.toFixed(3)}→${CHAT_TOKEN_CORRECTION_FACTOR.toFixed(3)} | Pred: ${LAST_PREDICTED_SIZE} Actual: ${actualSize} (${((actualSize - LAST_PREDICTED_SIZE) / LAST_PREDICTED_SIZE * 100).toFixed(1)}%)`);
        debug_trunc(`  Chat: pred ${LAST_PREDICTED_CHAT_SIZE} actual ${actualChatTokens} | Non-chat: pred ${LAST_PREDICTED_NON_CHAT_SIZE} actual ${actualNonChatTokens}`);
        
        // V34 BUG-002 FIX: Defensive save after correction factor update
        // Ensures factor is persisted immediately after being learned
        save_truncation_index();

        // V33: Update learned non-chat ratio for future fallback
        // NOTE: Must be inside this block because actualNonChatTokens is defined here
        if (actualSize > 0 && actualNonChatTokens > 0) {
            LAST_KNOWN_NON_CHAT_RATIO = actualNonChatTokens / actualSize;
            // Clamp to reasonable bounds (20% - 60%)
            LAST_KNOWN_NON_CHAT_RATIO = Math.max(0.20, Math.min(0.60, LAST_KNOWN_NON_CHAT_RATIO));
        }
    }
    
    // Determine color based on error percentage
    let bgColor, textColor;
    if (percentError <= 5) {
        bgColor = '#2d5016'; // dark green
        textColor = '#90ee90'; // light green
    } else if (percentError <= 20) {
        bgColor = '#4a4a00'; // dark yellow
        textColor = '#ffff99'; // light yellow
    } else {
        bgColor = '#4a0000'; // dark red
        textColor = '#ffaaaa'; // light red
    }
    
    $display.css({
        'background-color': bgColor,
        'color': textColor
    });
    
    const statusText = `
        <div>Actual: <b>${actualSize.toLocaleString()}</b> tokens</div>
        <div>Target: <b>${targetSize.toLocaleString()}</b> tokens</div>
        <div>Difference: <b>${difference > 0 ? '+' : ''}${difference.toLocaleString()}</b> tokens</div>
        <div>Error: <b>${percentError.toFixed(1)}%</b></div>
    `;
    
    debug(`  Setting status text and showing display`);
    debug(`  Status text: ${statusText.substring(0, 100)}...`);
    $text.html(statusText);
    $display.show();
    debug(`  Display shown, visibility: ${$display.css('display')}`);
    
    LAST_ACTUAL_PROMPT_SIZE = actualSize;
    
    // Call generation summary with collected data
    const ctx = getContext();
    const chat = ctx.chat;
    const summaryIndexes = collect_summary_indexes();
    const summaryInjection = get_summary_injection();
    const summaryTokens = summaryInjection ? count_tokens(summaryInjection) : 0;
    
    log_generation_summary({
        chatLength: chat.length,
        oldIndex: TRUNCATION_INDEX || 0,
        newIndex: TRUNCATION_INDEX || 0,
        actualTokens: actualSize,
        targetTokens: get_settings('target_context_size'),
        factor: CHAT_TOKEN_CORRECTION_FACTOR,
        state: CALIBRATION_STATE,
        stableCount: STABLE_COUNT,
        stableThreshold: STABLE_THRESHOLD,
        segmentCount: DEBUG_SEGMENT_COUNT,
        mapHits: DEBUG_MAP_HITS,
        mapMisses: DEBUG_MAP_MISSES,
        summaryCount: summaryIndexes.length,
        summaryTokens: summaryTokens,
        droppedCount: DROPPED_SUMMARY_COUNT,
        estimationMode: USING_ESTIMATION_MODE
    });
    
    // Run auto-calibration if enabled
    if (get_settings('auto_calibrate_target')) {
        calibrate_target_size(actualSize);
    }
    
    // Update memory display
    update_memory_display();
    
    // Update overview tab
    update_overview_tab();
}

// ==================== AUTO-CALIBRATION STATE MACHINE ====================

// Reset calibration state
function reset_calibration() {
    CALIBRATION_STATE = 'WAITING';
    GENERATION_COUNT = 0;
    STABLE_COUNT = 0;
    RETRAIN_COUNT = 0;
    CHAT_TOKEN_CORRECTION_FACTOR = 1.0;
    LAST_STABLE_CHAT_LENGTH = 0;  // V33: Clear STABLE tracking

    debug('Calibration reset to WAITING');
    update_calibration_ui();
    
    toastr.info('Calibration reset - will start when context threshold is reached', MODULE_NAME_FANCY);
}

// Auto-calibrate target context size based on actual usage
function calibrate_target_size(actualSize) {
    const maxContext = getMaxContextSize();
    const targetUtilization = get_settings('target_utilization');
    const autoCalibrate = get_settings('auto_calibrate_target');
    const idealTarget = Math.floor(maxContext * targetUtilization);
    
    // Calculate the threshold for when to start calibrating
    // ALWAYS use target_context_size as threshold
    // The ideal (maxContext * targetUtilization) is what we calibrate TOWARD, not what we wait FOR
    const startThreshold = get_settings('target_context_size');
    
    // Update Qdrant token history for averaging (Fix 3.2)
    update_qdrant_token_history();
    
    // Fix 3.1: Use dynamic tolerance that accounts for Qdrant variance
    const tolerance = get_dynamic_tolerance();
    
    // V33 FIX: Calculate deviation against calibrated target, not utilization
    // Question: "Is actual prompt close to our target_context_size?"
    // NOT: "Is actualSize/maxContext close to targetUtilization?"
    let calibratedTarget = get_settings('target_context_size');
    
    // V34 FIX: Do NOT subtract Qdrant tokens from calibration target.
    // The truncation system already handles Qdrant in calculate_truncation_index().
    // Subtracting here causes double-subtraction and unreachable targets.
    // Calibration should compare actualSize against the RAW target_context_size.
    if (get_settings('qdrant_enabled') && get_settings('account_qdrant_tokens')) {
        const qdrantAvg = get_averaged_qdrant_tokens();
        debug_trunc(`  Qdrant tokens (info only, not subtracted from calibration target): ${qdrantAvg}`);
    }
    
    const deviation = Math.abs((actualSize - calibratedTarget) / calibratedTarget);
    
    // Keep utilization for display/logging purposes
    const currentUtilization = actualSize / maxContext;
    
    
    switch (CALIBRATION_STATE) {
        case 'WAITING':
            // Check if we've reached the threshold to start calibrating
            // V34 BUG-001 FIX: Also check if truncation is active (messages being excluded)
            // If truncation is active, we should start calibrating immediately even if under threshold
            const truncationActive = TRUNCATION_INDEX !== null && TRUNCATION_INDEX > 0;
            
            if (actualSize < startThreshold && !truncationActive) {
            } else {
                // Transition to INITIAL_TRAINING
                CALIBRATION_STATE = 'INITIAL_TRAINING';
                GENERATION_COUNT = 0;
                // REQ-003: Removed threshold popup - state transition is silent
            }
            break;
            
        case 'INITIAL_TRAINING':
            // Wait for correction factor to stabilize
            GENERATION_COUNT++;

            if (GENERATION_COUNT >= TRAINING_GENERATIONS) {
                CALIBRATION_STATE = 'CALIBRATING';
                GENERATION_COUNT = 0;
                // V33: Initialize chat length tracking for index locking
                LAST_STABLE_CHAT_LENGTH = getContext().chat?.length || 0;
                debug_trunc(`Entering CALIBRATING with ${LAST_STABLE_CHAT_LENGTH} messages`);
                // Calculate initial target based on learned correction factor
                calculate_calibrated_target(maxContext, targetUtilization);
            }
            break;
            
        case 'CALIBRATING':
            // V34 FIX: Use factor convergence for stability, not deviation
            // Factor convergence is more stable than target deviation
            const factorChange = Math.abs(CHAT_TOKEN_CORRECTION_FACTOR - LAST_CORRECTION_FACTOR);
            const factorConverged = factorChange < 0.02;  // < 2% change = converged

            // Update factor tracking
            LAST_CORRECTION_FACTOR = CHAT_TOKEN_CORRECTION_FACTOR;

            debug_trunc(`Factor convergence: ${(factorChange * 100).toFixed(2)}% change (threshold: 2%)`);

            if (factorConverged) {
                STABLE_COUNT++;
                debug_trunc(`Factor converged! Stable count: ${STABLE_COUNT}/${STABLE_THRESHOLD}`);

                if (STABLE_COUNT >= STABLE_THRESHOLD) {
                    CALIBRATION_STATE = 'STABLE';
                    // V33: Track chat length for STABLE state locking
                    LAST_STABLE_CHAT_LENGTH = getContext().chat?.length || 0;
                    debug_trunc(`Entering STABLE state with ${LAST_STABLE_CHAT_LENGTH} messages`);
                    toastr.success(`Calibration complete! Target: ${get_settings('target_context_size').toLocaleString()} tokens`, MODULE_NAME_FANCY);
                }
            } else {
                // Factor still changing - decay stable count only for very large swings
                // Relaxed threshold: only decay if factor is swinging extremely wildly (> 10% change)
                if (factorChange > 0.10) {
                    STABLE_COUNT = Math.max(0, STABLE_COUNT - 1);
                    debug_trunc(`Factor unstable (${(factorChange * 100).toFixed(1)}% change), stable count: ${STABLE_COUNT}`);
                }
                // Don't recalculate target during calibration - just learn the factor
                // calculate_calibrated_target() removed to prevent instability
            }
            break;
            
        case 'RETRAINING':
            // Similar to initial training but after destabilization
            RETRAIN_COUNT++;
            
            if (RETRAIN_COUNT >= TRAINING_GENERATIONS) {
                CALIBRATION_STATE = 'CALIBRATING';
                RETRAIN_COUNT = 0;
                STABLE_COUNT = 0;
                calculate_calibrated_target(maxContext, targetUtilization);
            }
            break;
            
        case 'STABLE':
            // Monitor for destabilization
            if (deviation > tolerance * 1.5) {  // Use 1.5x tolerance to avoid bouncing
                CALIBRATION_STATE = 'RETRAINING';
                RETRAIN_COUNT = 0;
                STABLE_COUNT = 0;
                LAST_STABLE_CHAT_LENGTH = 0;  // V33: Clear STABLE tracking
                toastr.warning('Calibration destabilized - retraining...', MODULE_NAME_FANCY);
            }
            break;
    }
    
    // Single calibration summary line
    debug_trunc(`Calibration: ${CALIBRATION_STATE} | Dev: ${(deviation * 100).toFixed(1)}% | Stable: ${STABLE_COUNT}/${STABLE_THRESHOLD}`);
    
    save_truncation_index();
    update_calibration_ui();
    update_overview_tab();  // BUG-001 FIX: Sync Overview tab after state transitions
}

// Calculate and set calibrated target
function calculate_calibrated_target(maxContext, targetUtilization) {
    // Use correction factor to estimate how much to adjust
    // If correction factor > 1, we're underestimating (need higher target)
    // If correction factor < 1, we're overestimating (need lower target)
    
    const idealTarget = Math.floor(maxContext * targetUtilization);
    
    // V35 FIX: Remove Qdrant adjustment here - it's already handled in calculate_truncation_index()
    // via the Synergy adjustment. Double-subtracting causes underutilization.
    // Log the average for debugging but don't subtract it again.
    if (get_settings('qdrant_enabled') && get_settings('account_qdrant_tokens')) {
        const qdrantAvg = get_averaged_qdrant_tokens();
        debug_trunc(`    Qdrant token average: ${qdrantAvg} (already subtracted in truncation calc, not applied here)`);
    }
    
    // Fix 4.1: Dampened target adjustment - move only 70% toward the ideal
    // This prevents overcorrection and oscillation
    const rawAdjustedTarget = Math.floor(idealTarget / CHAT_TOKEN_CORRECTION_FACTOR);
    const currentTarget = get_settings('target_context_size');
    const dampingFactor = 0.7;  // Only move 70% of the way to the new target
    const adjustedTarget = Math.floor(currentTarget + (rawAdjustedTarget - currentTarget) * dampingFactor);
    
    // Clamp to reasonable bounds
    const minTarget = Math.floor(maxContext * 0.3);  // At least 30% of max
    const maxTarget = Math.floor(maxContext * 0.95); // At most 95% of max
    const finalTarget = Math.max(minTarget, Math.min(maxTarget, adjustedTarget));
    
    debug_trunc(`  Calculating calibrated target:`);
    debug_trunc(`    Ideal target: ${idealTarget}`);
    debug_trunc(`    Correction factor: ${CHAT_TOKEN_CORRECTION_FACTOR.toFixed(3)}`);
    debug_trunc(`    Raw adjusted target: ${rawAdjustedTarget}`);
    debug_trunc(`    Dampened target: ${adjustedTarget}`);
    debug_trunc(`    Final target: ${finalTarget}`);
    
    // V33: Reduced from 5% to 3% - dampening already prevents oscillation
    const changePct = Math.abs(finalTarget - currentTarget) / currentTarget;
    
    if (changePct > 0.03) {
        set_settings('target_context_size', finalTarget);
        $('#ct_target_size').val(finalTarget);
        
        // V34 FIX: Only reset truncation index if NOT in active calibration
        // Resetting during calibration destabilizes convergence
        if (CALIBRATION_STATE !== 'CALIBRATING' && CALIBRATION_STATE !== 'RETRAINING') {
            reset_truncation_index();
            debug_trunc(`  Reset truncation index (not in active calibration)`);
        } else {
            debug_trunc(`  Skipped truncation reset (in ${CALIBRATION_STATE} state)`);
        }
        
        debug_trunc(`  Updated target from ${currentTarget} to ${finalTarget}`);
    } else {
        debug_trunc(`  Target change too small (${(changePct * 100).toFixed(1)}%), keeping ${currentTarget}`);
    }
}

// Fix 3.1: Get dynamic tolerance that accounts for Qdrant variance
function get_dynamic_tolerance() {
    const baseTolerance = get_settings('calibration_tolerance');
    
    if (!get_settings('qdrant_enabled') || QDRANT_TOKEN_HISTORY.length < 2) {
        return baseTolerance;
    }
    
    // Calculate variance in Qdrant tokens
    const avg = QDRANT_TOKEN_HISTORY.reduce((a, b) => a + b, 0) / QDRANT_TOKEN_HISTORY.length;
    const variance = QDRANT_TOKEN_HISTORY.reduce((sum, val) => sum + Math.pow(val - avg, 2), 0) / QDRANT_TOKEN_HISTORY.length;
    const stdDev = Math.sqrt(variance);
    
    // Add extra tolerance based on Qdrant variance (as percentage of max context)
    const maxContext = getMaxContextSize();
    const varianceTolerance = (stdDev / maxContext) * 2;  // 2x std dev as extra tolerance
    
    const dynamicTolerance = Math.min(baseTolerance + varianceTolerance, 0.15);  // Cap at 15%
    
    debug_trunc(`  Dynamic tolerance: ${(dynamicTolerance * 100).toFixed(1)}% (base: ${(baseTolerance * 100).toFixed(1)}%, variance: ${(varianceTolerance * 100).toFixed(1)}%)`);
    
    return dynamicTolerance;
}

// Fix 3.2: Get averaged Qdrant tokens for stable estimation
function get_averaged_qdrant_tokens() {
    if (QDRANT_TOKEN_HISTORY.length === 0) {
        return get_qdrant_injection_tokens();
    }
    
    return Math.floor(QDRANT_TOKEN_HISTORY.reduce((a, b) => a + b, 0) / QDRANT_TOKEN_HISTORY.length);
}

// Update Qdrant token history
function update_qdrant_token_history() {
    const currentTokens = get_qdrant_injection_tokens();
    
    if (currentTokens > 0) {
        QDRANT_TOKEN_HISTORY.push(currentTokens);
        
        // Keep only the last N samples
        if (QDRANT_TOKEN_HISTORY.length > QDRANT_HISTORY_SIZE) {
            QDRANT_TOKEN_HISTORY.shift();
        }
        
        debug_qdrant(`Qdrant token history updated: ${currentTokens} tokens (${QDRANT_TOKEN_HISTORY.length} samples)`);
    }
}

// Update calibration UI
function update_calibration_ui() {
    const $panel = $('#ct_calibration_status');
    const $phase = $('#ct_calibration_phase');
    const $progress = $('#ct_calibration_progress');
    const $target = $('#ct_calibration_target');
    const $utilization = $('#ct_calibration_utilization');
    
    if (!get_settings('auto_calibrate_target')) {
        $panel.hide();
        return;
    }
    
    $panel.show();
    
    // Update phase with color coding
    $phase.removeClass('ct_phase_waiting ct_phase_training ct_phase_calibrating ct_phase_retraining ct_phase_stable');
    
    const maxContext = getMaxContextSize();
    const autoCalibrate = get_settings('auto_calibrate_target');
    // Threshold is always target_context_size (matches calibrate_target_size logic)
    const startThreshold = get_settings('target_context_size');
    
    switch (CALIBRATION_STATE) {
        case 'WAITING':
            $phase.text('Waiting').addClass('ct_phase_waiting');
            // REQ-004: Always show 0/TRAINING_GENERATIONS format in WAITING state
            $progress.text(`0/${TRAINING_GENERATIONS}`);
            break;
        case 'INITIAL_TRAINING':
            $phase.text('Training').addClass('ct_phase_training');
            $progress.text(`${GENERATION_COUNT}/${TRAINING_GENERATIONS} generations`);
            break;
        case 'CALIBRATING':
            $phase.text('Calibrating').addClass('ct_phase_calibrating');
            // Training is complete in CALIBRATING phase, show checkmark
            $progress.text(`${TRAINING_GENERATIONS}/${TRAINING_GENERATIONS} ✓`);
            break;
        case 'RETRAINING':
            $phase.text('Retraining').addClass('ct_phase_retraining');
            $progress.text(`${RETRAIN_COUNT}/${TRAINING_GENERATIONS} generations`);
            break;
        case 'STABLE':
            $phase.text('Stable ✓').addClass('ct_phase_stable');
            $progress.text('Monitoring');
            break;
    }
    
    // Update target and utilization
    $target.text(`${get_settings('target_context_size').toLocaleString()} tokens`);
    
    if (LAST_ACTUAL_PROMPT_SIZE > 0) {
        const utilization = (LAST_ACTUAL_PROMPT_SIZE / maxContext * 100).toFixed(1);
        $utilization.text(`${utilization}%`);
    } else {
        $utilization.text('-');
    }
    
    // Update stability UI
    update_stability_ui();
}

// Update stability progress UI display (V33)
function update_stability_ui() {
    const $stableCount = $('#ct_ov_stable_count');
    
    if ($stableCount.length === 0) return;
    
    const requiredStable = STABLE_THRESHOLD; // Use actual constant (5)
    const countText = `${STABLE_COUNT}/${requiredStable}`;
    $stableCount.text(countText);
    
    // Color coding: green when close to stable
    $stableCount.removeClass('ct_text_green ct_text_yellow ct_text_red');
    if (STABLE_COUNT >= requiredStable) {
        $stableCount.addClass('ct_text_green');
    } else if (STABLE_COUNT >= requiredStable - 1) {
        $stableCount.addClass('ct_text_yellow');
    }
    // Otherwise default white text
}

// ==================== OVERVIEW TAB FUNCTIONS ====================

// Calculate World Rules tokens from raw prompt
// World Rules are bounded by "## Lore:" and "## [AnyName]'s Persona:" (flexible matching)
function calculate_world_rules_tokens(raw_prompt) {
    if (!raw_prompt) return 0;

    // Use flexible regex patterns to handle variations in spacing/formatting
    const lorePattern = /##\s*Lore:/i;
    // Match any name followed by "'s Persona:" - the name is replaced from {{user}} placeholder
    const personaPattern = /##\s*.+?'s Persona:/i;

    const loreMatch = raw_prompt.match(lorePattern);
    if (!loreMatch) return 0;

    const startIndex = loreMatch.index;

    // Search for persona marker after the lore marker
    const afterLore = raw_prompt.substring(startIndex);
    const personaMatch = afterLore.match(personaPattern);
    if (!personaMatch) return 0;

    const endIndex = startIndex + personaMatch.index;

    const worldRulesSection = raw_prompt.substring(startIndex, endIndex);
    return count_tokens(worldRulesSection);
}

// Calculate LoreVault tokens from raw prompt
// LoreVault content is bounded by [STORY MEMORY] and [/STORY MEMORY]
function calculate_lorevault_tokens(raw_prompt) {
    if (!raw_prompt) return 0;

    const startMarker = '[STORY MEMORY]';
    const endMarker = '[/STORY MEMORY]';

    const startIndex = raw_prompt.indexOf(startMarker);
    if (startIndex === -1) return 0;

    const endIndex = raw_prompt.indexOf(endMarker, startIndex);
    if (endIndex === -1) return 0;

    const content = raw_prompt.substring(startIndex, endIndex + endMarker.length);
    return count_tokens(content);
}

// Update the Overview tab with current stats
function update_overview_tab() {
    // VIS-001 FIX: Handle initial state (no prompt yet)
    const last_raw_prompt = get_last_prompt_raw();
    if (!last_raw_prompt) {
        $('#ct_gauge_fill').css('width', '0%');
        $('#ct_gauge_value').text('0.0%');
        $('#ct_gauge_max').text('Waiting for first generation...');
        
        // REQ-002 FIX: Update Cal. Progress even without prompt data
        if (get_settings('auto_calibrate_target')) {
            $('#ct_ov_cal_phase').text('Waiting')
                .removeClass('ct_phase_waiting ct_phase_training ct_phase_calibrating ct_phase_retraining ct_phase_stable')
                .addClass('ct_phase_waiting');
            $('#ct_ov_cal_progress').text('0/2');
        } else {
            $('#ct_ov_cal_phase').text('Disabled')
                .removeClass('ct_phase_waiting ct_phase_training ct_phase_calibrating ct_phase_retraining ct_phase_stable');
            $('#ct_ov_cal_progress').text('--');
        }
        return;
    }

    const maxContext = getMaxContextSize();

    // Declare actualSize at function scope with default
    let actualSize = 0;

    // Update Gauge
    if (last_raw_prompt && maxContext > 0) {
        actualSize = count_tokens(last_raw_prompt);
        
        // Calculate CORRECTED estimate (what API will actually receive)
        // This is what users care about - not the internal tokenizer output
        const correctedActualSize = Math.floor(actualSize * CHAT_TOKEN_CORRECTION_FACTOR);
        const utilization = (correctedActualSize / maxContext * 100);
        
        // Sanity check - utilization should be between 0 and 150%
        if (utilization >= 0 && utilization <= 150) {
            LAST_VALID_UTILIZATION = utilization;
            LAST_VALID_MAX_CONTEXT = maxContext;

            // Update gauge fill
            const $gaugeFill = $('#ct_gauge_fill');
            $gaugeFill.css('width', `${Math.min(utilization, 100)}%`);
            // ... rest of gauge update

            // Show CORRECTED value with "(est)" suffix to indicate it's estimated
            $('#ct_gauge_value').text(`${utilization.toFixed(1)}%`);
            $('#ct_gauge_max').text(`of ${maxContext.toLocaleString()} tokens (est)`);
        } else {
            // Invalid utilization - use cached or show placeholder
            if (LAST_VALID_UTILIZATION !== null) {
                // Use last known good values
                $('#ct_gauge_value').text(`${LAST_VALID_UTILIZATION.toFixed(1)}%`);
                $('#ct_gauge_max').text(`of ${LAST_VALID_MAX_CONTEXT.toLocaleString()} tokens`);
            } else {
                // Show placeholder
                $('#ct_gauge_value').text('--%');
            }
        }
    } else {
        // No data available
        if (LAST_VALID_UTILIZATION !== null && LAST_VALID_MAX_CONTEXT !== null) {
            // Keep showing last valid data
            $('#ct_gauge_value').text(`${LAST_VALID_UTILIZATION.toFixed(1)}%`);
            $('#ct_gauge_max').text(`of ${LAST_VALID_MAX_CONTEXT.toLocaleString()} tokens`);
        } else {
            // V32: Show clear "waiting" state instead of confusing zeros
            $('#ct_gauge_fill').css('width', '0%');
            $('#ct_gauge_value').text('--');
            $('#ct_gauge_max').text(`Waiting for first generation`);
        }
    }

    // Update Breakdown Bar (now includes World Rules)
    // Only calculate breakdown if we have a valid actualSize and maxContext
    if (last_raw_prompt && actualSize > 0 && maxContext > 0) {
        const segments = get_prompt_chat_segments_from_raw(last_raw_prompt);
        const chatTokens = segments ? segments.reduce((sum, seg) => sum + seg.tokenCount, 0) : 0;
        const worldRulesTokens = calculate_world_rules_tokens(last_raw_prompt);
        const lorevaultTokens = calculate_lorevault_tokens(last_raw_prompt);
        const summaryTokens = count_tokens(get_summary_injection());
        const qdrantTokens = get_qdrant_injection_tokens();
        // System is everything else (total - chat - worldRules - lorevault - summaries - qdrant)
        const systemTokens = Math.max(0, actualSize - chatTokens - worldRulesTokens - lorevaultTokens - summaryTokens - qdrantTokens);
        
        // Use corrected values for breakdown so it matches the gauge
        const correctedChatTokens = Math.floor(chatTokens * CHAT_TOKEN_CORRECTION_FACTOR);
        const correctedSystemTokens = Math.floor(systemTokens * CHAT_TOKEN_CORRECTION_FACTOR);
        // NOTE: Summary and Qdrant tokens are already counted separately and don't need correction
        const correctedActualSize = Math.floor(actualSize * CHAT_TOKEN_CORRECTION_FACTOR);
        const freeTokens = Math.max(0, maxContext - correctedActualSize);

        const chatPct = (correctedChatTokens / maxContext * 100);
        const systemPct = (correctedSystemTokens / maxContext * 100);
        const worldRulesPct = (worldRulesTokens / maxContext * 100);
        const lorevaultPct = (lorevaultTokens / maxContext * 100);
        const summaryPct = (summaryTokens / maxContext * 100);
        const qdrantPct = (qdrantTokens / maxContext * 100);
        const freePct = (freeTokens / maxContext * 100);
        
        $('#ct_breakdown_chat').css('width', `${chatPct}%`);
        $('#ct_breakdown_system').css('width', `${systemPct}%`);
        $('#ct_breakdown_worldrules').css('width', `${worldRulesPct}%`);
        $('#ct_breakdown_lorevault').css('width', `${lorevaultPct}%`);
        $('#ct_breakdown_summaries').css('width', `${summaryPct}%`);
        $('#ct_breakdown_qdrant').css('width', `${qdrantPct}%`);
        $('#ct_breakdown_free').css('width', `${freePct}%`);
        
        // Update token counts in foldable section with corrected values
        $('#ct_breakdown_chat_tokens').text(`${correctedChatTokens.toLocaleString()} tokens`);
        $('#ct_breakdown_system_tokens').text(`${correctedSystemTokens.toLocaleString()} tokens`);
        $('#ct_breakdown_worldrules_tokens').text(`${worldRulesTokens.toLocaleString()} tokens`);
        $('#ct_breakdown_lorevault_tokens').text(`${lorevaultTokens.toLocaleString()} tokens`);
        $('#ct_breakdown_summaries_tokens').text(`${summaryTokens.toLocaleString()} tokens`);
        $('#ct_breakdown_qdrant_tokens').text(`${qdrantTokens.toLocaleString()} tokens`);
        $('#ct_breakdown_free_tokens').text(`${freeTokens.toLocaleString()} tokens`);
        $('#ct_breakdown_total_tokens').html(`<strong>${correctedActualSize.toLocaleString()} / ${maxContext.toLocaleString()} tokens (est)</strong>`);
        
        // Update Truncation Stats Card (now simplified)
        const targetSize = get_settings('target_context_size');
        const difference = actualSize - targetSize;
        const percentError = Math.abs((difference / targetSize) * 100);
        
        // Simplified context display (actual / target)
        $('#ct_ov_actual_size_short').text(actualSize.toLocaleString());
        $('#ct_ov_target_size_short').text(targetSize.toLocaleString());
        
        // Legacy element support (for any remaining references)
        $('#ct_ov_actual_size').text(`${actualSize.toLocaleString()} tokens`);
        $('#ct_ov_target_size').text(`${targetSize.toLocaleString()} tokens`);
        
        // Advanced stats (in collapsible section)
        $('#ct_ov_difference').text(`${difference > 0 ? '+' : ''}${difference.toLocaleString()}`);
        $('#ct_ov_error').text(`${percentError.toFixed(1)}%`);
        $('#ct_ov_trunc_index').text(TRUNCATION_INDEX !== null ? TRUNCATION_INDEX : '--');
        // Display correction factor with color coding
        const factor = CHAT_TOKEN_CORRECTION_FACTOR;
        $('#ct_ov_correction').text(factor.toFixed(3));
        
        // Color code: green if reasonable (0.7-1.1), yellow if borderline, red if extreme
        $('#ct_ov_correction').removeClass('ct_text_green ct_text_yellow ct_text_red');
        if (factor >= 0.7 && factor <= 1.1) {
            // Reasonable range - no special color
        } else if (factor >= 0.5 && factor <= 1.3) {
            $('#ct_ov_correction').addClass('ct_text_yellow');
        } else {
            $('#ct_ov_correction').addClass('ct_text_red');
        }
        
    } else {
        // No data available
        $('#ct_gauge_fill').css('width', '0%');
        $('#ct_gauge_value').text('--%');
        $('#ct_gauge_max').text(`of ${maxContext.toLocaleString()} tokens`);
    }
    
    // Update Calibration Status Card
    if (get_settings('auto_calibrate_target')) {
        let phaseText = CALIBRATION_STATE;
        let phaseClass = '';
        let progressText = '--';
        
        const autoCalibrate = get_settings('auto_calibrate_target');
        // Threshold is always target_context_size (matches calibrate_target_size logic)
        const startThreshold = get_settings('target_context_size');
        
        switch (CALIBRATION_STATE) {
            case 'WAITING':
                phaseText = 'Waiting';
                phaseClass = 'ct_phase_waiting';
                // REQ-004: Always show 0/TRAINING_GENERATIONS format
                progressText = `0/${TRAINING_GENERATIONS}`;
                break;
            case 'INITIAL_TRAINING':
                phaseText = 'Training';
                phaseClass = 'ct_phase_training';
                progressText = `${GENERATION_COUNT}/${TRAINING_GENERATIONS}`;
                break;
            case 'CALIBRATING':
                phaseText = 'Calibrating';
                phaseClass = 'ct_phase_calibrating';
                // Training is complete in CALIBRATING phase, show checkmark
                progressText = `${TRAINING_GENERATIONS}/${TRAINING_GENERATIONS} ✓`;
                break;
            case 'RETRAINING':
                phaseText = 'Retraining';
                phaseClass = 'ct_phase_retraining';
                progressText = `${RETRAIN_COUNT}/${TRAINING_GENERATIONS}`;
                break;
            case 'STABLE':
                phaseText = 'Stable ✓';
                phaseClass = 'ct_phase_stable';
                progressText = 'Monitoring';
                break;
        }
        
        $('#ct_ov_cal_phase').text(phaseText).removeClass('ct_phase_waiting ct_phase_training ct_phase_calibrating ct_phase_retraining ct_phase_stable').addClass(phaseClass);
        $('#ct_ov_cal_progress').text(progressText);
        $('#ct_ov_cal_target').text(`${get_settings('target_context_size').toLocaleString()} tokens`);
        
        if (LAST_ACTUAL_PROMPT_SIZE > 0) {
            const utilization = (LAST_ACTUAL_PROMPT_SIZE / maxContext * 100).toFixed(1);
            $('#ct_ov_cal_util').text(`${utilization}%`);
        } else {
            $('#ct_ov_cal_util').text('-');
        }
    } else {
        $('#ct_ov_cal_phase').text('Disabled').removeClass('ct_phase_waiting ct_phase_training ct_phase_calibrating ct_phase_retraining ct_phase_stable');
        $('#ct_ov_cal_progress').text('--');
        $('#ct_ov_cal_target').text(`${get_settings('target_context_size').toLocaleString()} tokens`);
        $('#ct_ov_cal_util').text('-');
    }
    
    // Update Qdrant Memory Section in Overview
    update_overview_memories();

    // Update Vector Statistics (V11)
    update_vector_stats_display();

    // Update Predictions and Summarization Stats
    update_prediction_display();
    update_summary_stats_display();
}

// ==================== SUMMARIZATION STATISTICS ====================

// Collect summarization statistics from the current chat
function collect_summarization_stats() {
    const ctx = getContext();
    const chat = ctx.chat;
    
    const stats = {
        totalMessages: 0,      // Total non-system messages
        truncated: 0,          // Messages excluded from context (lagging)
        summarized: 0,         // Truncated messages that have summaries
        pending: 0,            // Truncated messages without summaries (not in queue)
        inQueue: 0,            // Messages currently being processed
        inContext: 0           // Messages still in active context
    };
    
    if (!chat || chat.length === 0) {
        return stats;
    }
    
    // FIX: Handle null/undefined TRUNCATION_INDEX properly
    const truncIndex = TRUNCATION_INDEX || 0;
    const queueIndexes = new Set(summaryQueue.queue);

    for (let i = 0; i < chat.length; i++) {
        const message = chat[i];

        // Skip system messages
        if (message.is_system) {
            continue;
        }

        stats.totalMessages++;

        // FIX: Correct lagging check - message is excluded if i < truncIndex
        const lagging = truncIndex > 0 && i < truncIndex;  // Message is excluded from context
        const hasSummary = !!get_memory(message);
        const inQueue = queueIndexes.has(i);
        
        // Context status (independent of queue status)
        if (lagging) {
            stats.truncated++;
            
            // Summarization status for truncated messages
            if (hasSummary) {
                stats.summarized++;
            } else if (inQueue) {
                stats.inQueue++;
            } else {
                stats.pending++;
            }
        } else {
            stats.inContext++;
        }
    }
    
    return stats;
}

// Estimate how many generations until next batch trim
function estimate_generations_to_trim() {
    const ctx = getContext();
    const chat = ctx.chat;
    
    if (!chat || chat.length === 0 || !LAST_ACTUAL_PROMPT_SIZE) {
        return { generations: null, roomLeft: null };
    }
    
    const targetSize = get_settings('target_context_size');
    const batchSize = get_settings('batch_size');
    
    // Calculate room left until target is exceeded
    const roomLeft = Math.max(0, targetSize - LAST_ACTUAL_PROMPT_SIZE);
    
    if (roomLeft <= 0) {
        return { generations: 0, roomLeft: 0 };
    }
    
    // Estimate average tokens per generation from recent messages
    // Look at the last few messages to get an average
    const lookbackCount = 5;
    let totalTokens = 0;
    let messageCount = 0;
    
    for (let i = Math.max(0, chat.length - lookbackCount); i < chat.length; i++) {
        const message = chat[i];
        if (!message.is_system && message.mes) {
            totalTokens += count_tokens(message.mes);
            messageCount++;
        }
    }
    
    if (messageCount === 0) {
        return { generations: null, roomLeft };
    }
    
    // Average tokens per message (assuming roughly 2 messages per generation: user + assistant)
    const avgTokensPerMessage = totalTokens / messageCount;
    const avgTokensPerGeneration = avgTokensPerMessage * 2;
    
    // Estimate generations until target exceeded
    const estimatedGenerations = Math.floor(roomLeft / avgTokensPerGeneration);
    
    return {
        generations: estimatedGenerations,
        roomLeft: roomLeft,
        avgTokensPerGen: Math.round(avgTokensPerGeneration)
    };
}

// Get calibration prediction text
function get_calibration_prediction() {
    if (!get_settings('auto_calibrate_target')) {
        return { text: 'Auto-Calibration Disabled', class: '' };
    }
    
    switch (CALIBRATION_STATE) {
        case 'WAITING':
            const maxContext = getMaxContextSize();
            const startThreshold = Math.floor(maxContext * get_settings('target_utilization'));
            const tokensNeeded = startThreshold - LAST_ACTUAL_PROMPT_SIZE;
            if (tokensNeeded > 0) {
                return {
                    text: `Waiting: ~${tokensNeeded.toLocaleString()} tokens until threshold`,
                    class: 'ct_text_muted'
                };
            }
            return {
                text: 'Threshold reached - starting soon',
                class: 'ct_text_yellow'
            };
        case 'INITIAL_TRAINING':
            const trainingLeft = TRAINING_GENERATIONS - GENERATION_COUNT;
            return {
                text: `Training: ${trainingLeft} gen${trainingLeft !== 1 ? 's' : ''} remaining`,
                class: 'ct_text_yellow'
            };
        case 'CALIBRATING':
            const calibratingLeft = STABLE_THRESHOLD - STABLE_COUNT;
            return {
                text: `Calibrating: ${calibratingLeft} stable gen${calibratingLeft !== 1 ? 's' : ''} needed`,
                class: 'ct_text_orange'
            };
        case 'RETRAINING':
            const retrainingLeft = TRAINING_GENERATIONS - RETRAIN_COUNT;
            return {
                text: `Retraining: ${retrainingLeft} gen${retrainingLeft !== 1 ? 's' : ''} remaining`,
                class: 'ct_text_blue'
            };
        case 'STABLE':
            return {
                text: 'Stable - Monitoring',
                class: 'ct_text_green'
            };
        default:
            return { text: 'Unknown', class: '' };
    }
}

// Update the Predictions Card in Overview
function update_prediction_display() {
    const trimEstimate = estimate_generations_to_trim();
    const calibrationPrediction = get_calibration_prediction();
    
    // Next Trim prediction (matches HTML ID: ct_ov_next_trim)
    // VIS-002 FIX: Show status during calibration instead of "(target exceeded)"
    const isTraining = CALIBRATION_STATE === 'INITIAL_TRAINING';
    const isCalibrating = ['CALIBRATING', 'RETRAINING'].includes(CALIBRATION_STATE);

    if (trimEstimate.generations !== null) {
        if (trimEstimate.generations === 0) {
            if (isTraining) {
                $('#ct_ov_next_trim').text('Training').removeClass('ct_text_orange');
            } else if (isCalibrating) {
                $('#ct_ov_next_trim').text('Calibrating...').removeClass('ct_text_orange');
            } else {
                $('#ct_ov_next_trim').text('Imminent (target exceeded)').addClass('ct_text_orange');
            }
        } else {
            $('#ct_ov_next_trim').text(`~${trimEstimate.generations} generation${trimEstimate.generations !== 1 ? 's' : ''}`).removeClass('ct_text_orange');
        }
    } else {
        $('#ct_ov_next_trim').text('--').removeClass('ct_text_orange');
    }
    
    // Room Left (matches HTML ID: ct_ov_room_left)
    if (trimEstimate.roomLeft !== null) {
        $('#ct_ov_room_left').text(`${trimEstimate.roomLeft.toLocaleString()} tokens`);
    } else {
        $('#ct_ov_room_left').text('--');
    }
    
    // Calibration Status (matches HTML ID: ct_ov_cal_status)
    $('#ct_ov_cal_status')
        .text(calibrationPrediction.text)
        .removeClass('ct_text_green ct_text_yellow ct_text_orange ct_text_blue')
        .addClass(calibrationPrediction.class);
}

// Update Summarization Stats Display (both Overview and Truncation tabs)
function update_summary_stats_display() {
    const stats = collect_summarization_stats();
    
    // Calculate counts for Version 2E design
    const excludedCount = stats.truncated;  // Messages excluded from context
    const summarizedCount = stats.summarized;  // Excluded messages with summaries
    const pendingCount = stats.pending + stats.inQueue;  // Excluded messages awaiting summarization

    // FIX: Safe coverage calculation (avoid division by zero)
    const coveragePercent = excludedCount > 0 ? Math.round((summarizedCount / excludedCount) * 100) : 0;
    
    // Update Overview tab Summaries card (Version 2E design)
    $('#ct_ov_excluded_count').text(`${excludedCount} messages`);
    $('#ct_ov_summarized_count').text(summarizedCount);
    $('#ct_ov_pending_count').text(pendingCount);
    
    // V22: Update dropped count (messages with summaries that exceeded token cap)
    $('#ct_ov_dropped_count').text(DROPPED_SUMMARY_COUNT);
    if (DROPPED_SUMMARY_COUNT > 0) {
        $('#ct_ov_dropped_count').addClass('ct_text_red');
    } else {
        $('#ct_ov_dropped_count').removeClass('ct_text_red');
    }
    
    // Update coverage indicator with percentage and appropriate class
    const $coverageIndicator = $('#ct_ov_summary_coverage');
    $coverageIndicator.removeClass('ct_coverage_good ct_coverage_partial ct_coverage_low ct_coverage_none');
    
    if (excludedCount === 0) {
        // No excluded messages yet
        $coverageIndicator.text('--').addClass('ct_coverage_none');
    } else if (coveragePercent >= 75) {
        // Good coverage (≥75%)
        $coverageIndicator.text(`${Math.round(coveragePercent)}% ✓`).addClass('ct_coverage_good');
    } else if (coveragePercent >= 25) {
        // Partial coverage (25-75%)
        $coverageIndicator.text(`${Math.round(coveragePercent)}% ⚠`).addClass('ct_coverage_partial');
    } else if (coveragePercent > 0) {
        // Low coverage (<25%)
        $coverageIndicator.text(`${Math.round(coveragePercent)}% ⚠`).addClass('ct_coverage_low');
    } else {
        // No coverage (0%)
        $coverageIndicator.text('0%').addClass('ct_coverage_none');
    }
    
    // Legacy: Update old element IDs if they still exist (backwards compatibility)
    $('#ct_ov_sum_total').text(excludedCount);
    $('#ct_ov_sum_done').text(summarizedCount);
    $('#ct_ov_sum_pending').text(stats.pending);
    $('#ct_ov_sum_queue').text(stats.inQueue);
    $('#ct_ov_sum_active').text(stats.inContext);
    
    // Update Truncation tab stats panel (matches HTML IDs: ct_sum_*_count)
    $('#ct_sum_total_count').text(stats.totalMessages);
    $('#ct_sum_done_count').text(stats.summarized);
    $('#ct_sum_pending_count').text(stats.pending);
    $('#ct_sum_queue_count').text(stats.inQueue);
    $('#ct_sum_active_count').text(stats.inContext);
    
    // Calculate percentages for progress bar (Truncation tab)
    const total = stats.totalMessages || 1;  // Avoid division by zero
    const pctDone = (stats.summarized / total) * 100;
    const pctPending = (stats.pending / total) * 100;
    const pctQueue = (stats.inQueue / total) * 100;
    const pctActive = (stats.inContext / total) * 100;
    
    // Update progress bar segments (Truncation tab)
    $('#ct_sum_bar_done').css('width', `${pctDone}%`);
    $('#ct_sum_bar_pending').css('width', `${pctPending}%`);
    $('#ct_sum_bar_queue').css('width', `${pctQueue}%`);
    $('#ct_sum_bar_active').css('width', `${pctActive}%`);
}

// Update the memory display in Overview tab
function update_overview_memories() {
    const $count = $('#ct_ov_memory_count');
    const $list = $('#ct_ov_memory_list');
    
    if (!get_settings('qdrant_enabled') || INJECTED_QDRANT_MEMORIES.length === 0) {
        $count.text('Retrieved Memories (0)');
        $list.html('<div class="ct_memory_empty">Generate a message to retrieve memories</div>');
        return;
    }

    const memories = INJECTED_QDRANT_MEMORIES;
    $count.text(`Retrieved Memories (${memories.length})`);
    
    // Build memory list HTML (reuse from update_memory_display)
    let html = '';
    for (let i = 0; i < memories.length; i++) {
        const memory = memories[i];
        const score = memory.score;
        const scorePercent = (score * 100).toFixed(1);
        
        let scoreClass = 'ct_score_low';
        if (score >= 0.7) scoreClass = 'ct_score_high';
        else if (score >= 0.5) scoreClass = 'ct_score_medium';
        
        const text = memory.text.length > 500
            ? memory.text.substring(0, 500) + '...'
            : memory.text;
        
        html += `
            <div class="ct_memory_item">
                <div class="ct_memory_item_header">
                    <span class="ct_memory_meta">Memory ${i + 1} • Messages ${memory.firstIndex}-${memory.lastIndex}</span>
                    <span class="ct_memory_score ${scoreClass}">${scorePercent}%</span>
                </div>
                <div class="ct_memory_text">${escapeHtml(text)}</div>
            </div>
        `;
    }
    
    $list.html(html);
}

// Update target size input state based on auto-calibration setting
function update_target_size_state() {
    const autoCalibrate = get_settings('auto_calibrate_target');
    const $targetSize = $('#ct_target_size');
    
    if (autoCalibrate) {
        $targetSize.prop('disabled', true);
        $targetSize.addClass('ct_disabled');
        $targetSize.attr('title', 'Disabled when Auto-Calibration is enabled');
    } else {
        $targetSize.prop('disabled', false);
        $targetSize.removeClass('ct_disabled');
        $targetSize.attr('title', '');
    }
}

// Update auto-limit summaries display value (V22)
function update_auto_limit_display() {
    const $display = $('#ct_auto_limit_value');
    
    if (!get_settings('auto_limit_summaries')) {
        $display.text('(manual)');
        return;
    }
    
    const maxContext = getMaxContextSize();
    const targetUtilization = get_settings('target_utilization') || 0.80;
    const autoLimit = Math.floor(maxContext * targetUtilization * 0.20);
    $display.text(`~${autoLimit.toLocaleString()} tokens`);
}

// ==================== POPOUT FUNCTIONS ====================

// Check if popout is currently visible
function isPopoutVisible() {
    return POPOUT_VISIBLE;
}

// Toggle the popout between open and closed states
function togglePopout() {
    if (POPOUT_VISIBLE) {
        closePopout();
    } else {
        openPopout();
    }
}

// Open the settings popout and move the drawer content inside it
function openPopout() {
    if (POPOUT_VISIBLE) return;
    
    const $drawer = $('#context_truncator_settings');
    const $drawerHeader = $drawer.find('.inline-drawer-header');
    const $drawerContentElement = $drawer.find('.inline-drawer-content');
    const isCollapsed = !$drawerContentElement.hasClass('open');
    
    // If collapsed, trigger click to open first
    if (isCollapsed) {
        $drawerHeader.trigger('click');
    }
    
    // Create the popout element with reset size button
    // VIS-006, VIS-007: Removed pie chart icon and X button
    $POPOUT = $(`
        <div id="ct_popout" class="draggable" style="display: none;">
            <div class="panelControlBar flex-container" id="ctPopoutHeader">
                <div class="title">${MODULE_NAME_FANCY}</div>
                <div class="flex1"></div>
                <div class="fa-solid fa-arrows-left-right hoverglow dragReset" title="Reset to default size"></div>
                <div class="fa-solid fa-grip drag-grabber hoverglow" title="Drag to move"></div>
                <div class="fa-solid fa-lock-open hoverglow dragLock" title="Lock position"></div>
            </div>
            <div id="ct_popout_content_container"></div>
        </div>
    `);
    
    // Append popout to body
    $('body').append($POPOUT);
    
    // Move drawer content to popout
    $drawerContentElement.detach().appendTo($POPOUT.find('#ct_popout_content_container'));
    $drawerContentElement.addClass('open').show();
    $DRAWER_CONTENT = $drawerContentElement;
    
    // Set up dragging using SillyTavern's dragElement if available
    try {
        const ctx = getContext();
        if (typeof ctx.dragElement === 'function') {
            ctx.dragElement($POPOUT);
            debug_trunc('Popout: Using SillyTavern dragElement');
        } else if (typeof window.dragElement === 'function') {
            window.dragElement($POPOUT);
            debug_trunc('Popout: Using window.dragElement');
        } else {
            // Fallback: Make header draggable manually
            make_popout_draggable($POPOUT);
            debug_trunc('Popout: Using fallback drag implementation');
        }
    } catch (e) {
        debug_trunc('Popout: Drag setup failed, using fallback', e);
        make_popout_draggable($POPOUT);
    }
    
    // Load saved position if available
    load_popout_position();
    
    // Set up button handlers
    $POPOUT.find('.dragClose').on('click', () => closePopout());
    $POPOUT.find('.dragLock').on('click', () => togglePopoutLock());
    $POPOUT.find('.dragReset').on('click', () => resetPopoutSize());
    
    // Set up ResizeObserver to track when user manually resizes
    try {
        const resizeObserver = new ResizeObserver(debounce((entries) => {
            for (const entry of entries) {
                // Mark that user has manually resized
                $POPOUT.data('user-resized', true);
                save_popout_position();
                debug_trunc('Popout resized by user');
            }
        }, 250));
        resizeObserver.observe($POPOUT[0]);
        
        // Store observer reference for cleanup
        $POPOUT.data('resize-observer', resizeObserver);
        debug_trunc('ResizeObserver attached to popout');
    } catch (e) {
        debug_trunc('ResizeObserver not available:', e);
    }
    
    // Show the popout with animation
    $POPOUT.fadeIn(250);
    
    // Update state
    POPOUT_VISIBLE = true;
    update_popout_button_state();
    
    debug_trunc('Popout opened');
}

// Close the settings popout and return the drawer content to its original location
function closePopout() {
    if (!POPOUT_VISIBLE || !$POPOUT) return;
    
    const $currentPopout = $POPOUT;
    const $currentDrawerContent = $DRAWER_CONTENT;
    
    // Save position before closing
    save_popout_position();
    
    // Cleanup ResizeObserver
    const resizeObserver = $currentPopout.data('resize-observer');
    if (resizeObserver) {
        resizeObserver.disconnect();
        debug_trunc('ResizeObserver disconnected');
    }
    
    $currentPopout.fadeOut(250, () => {
        const $drawer = $('#context_truncator_settings');
        const $inlineDrawer = $drawer.find('.inline-drawer');
        
        if ($currentDrawerContent) {
            // Move content back to drawer (inside .inline-drawer for correct toggle behavior)
            $currentDrawerContent.detach().appendTo($inlineDrawer);
            $currentDrawerContent.addClass('open').show();
        }
        
        // Remove popout element
        $currentPopout.remove();
        
        if ($POPOUT === $currentPopout) {
            $POPOUT = null;
        }
    });
    
    // Update state
    POPOUT_VISIBLE = false;
    $DRAWER_CONTENT = null;
    update_popout_button_state();
    
    debug_trunc('Popout closed');
}

// Toggle popout position lock
function togglePopoutLock() {
    if (!$POPOUT) return;
    
    POPOUT_LOCKED = !POPOUT_LOCKED;
    update_lock_button_ui();
    save_popout_position(); // Persist lock state immediately
    
    debug_trunc(`Popout position ${POPOUT_LOCKED ? 'locked' : 'unlocked'}`);
}

// Update the lock button UI state
function update_lock_button_ui() {
    if (!$POPOUT) return;
    
    const $button = $POPOUT.find('.dragLock');
    
    if (POPOUT_LOCKED) {
        $button.removeClass('fa-lock-open').addClass('fa-lock locked');
        $button.attr('title', 'Unlock position');
        $POPOUT.addClass('position-locked');
    } else {
        $button.removeClass('fa-lock locked').addClass('fa-lock-open');
        $button.attr('title', 'Lock position');
        $POPOUT.removeClass('position-locked');
    }
}

// Fallback drag implementation if SillyTavern's dragElement is not available
function make_popout_draggable($element) {
    const $header = $element.find('#ctPopoutHeader');
    let isDragging = false;
    let startX, startY, initialX, initialY;
    
    $header.on('mousedown', (e) => {
        // Don't drag if locked
        if (POPOUT_LOCKED) return;
        
        // Don't drag if clicking on close button, lock button, or other interactive elements
        if ($(e.target).hasClass('dragClose') || $(e.target).hasClass('dragLock') || $(e.target).hasClass('hoverglow')) {
            return;
        }
        
        isDragging = true;
        startX = e.clientX;
        startY = e.clientY;
        
        const rect = $element[0].getBoundingClientRect();
        initialX = rect.left;
        initialY = rect.top;
        
        $header.css('cursor', 'grabbing');
        e.preventDefault();
    });
    
    $(document).on('mousemove.ctPopout', (e) => {
        if (!isDragging) return;
        
        const deltaX = e.clientX - startX;
        const deltaY = e.clientY - startY;
        
        let newX = initialX + deltaX;
        let newY = initialY + deltaY;
        
        // Keep within viewport bounds
        const maxX = window.innerWidth - $element.outerWidth();
        const maxY = window.innerHeight - $element.outerHeight();
        
        newX = Math.max(0, Math.min(newX, maxX));
        newY = Math.max(0, Math.min(newY, maxY));
        
        $element.css({
            left: newX + 'px',
            top: newY + 'px',
            right: 'auto',
            bottom: 'auto'
        });
    });
    
    $(document).on('mouseup.ctPopout', () => {
        if (isDragging) {
            isDragging = false;
            $header.css('cursor', 'grab');
            save_popout_position();
        }
    });
}

// Save popout position to localStorage
// FIXED: Only saves width if user has manually resized the popout
function save_popout_position() {
    if (!$POPOUT) return;
    
    const position = {
        left: $POPOUT.css('left'),
        top: $POPOUT.css('top'),
        right: $POPOUT.css('right'),
        // Only save width if user has manually resized (avoids overriding CSS defaults)
        width: $POPOUT.data('user-resized') ? $POPOUT.css('width') : null,
        locked: POPOUT_LOCKED
    };
    
    localStorage.setItem('ct_popout_position', JSON.stringify(position));
    debug_trunc('Popout position saved:', position);
}

// Load popout position from localStorage
function load_popout_position() {
    if (!$POPOUT) return;
    
    const saved = localStorage.getItem('ct_popout_position');
    
    if (saved) {
        try {
            const position = JSON.parse(saved);
            $POPOUT.css({
                left: position.left || 'auto',
                top: position.top || 'var(--topBarBlockSize, 50px)',
                right: position.right || 'auto'
            });
            
            // Only apply saved width if it exists (user previously resized)
            if (position.width) {
                $POPOUT.css('width', position.width);
                $POPOUT.data('user-resized', true);
            }
            
            // Restore lock state
            if (position.locked !== undefined) {
                POPOUT_LOCKED = position.locked;
                update_lock_button_ui();
            }
            
            debug_trunc('Popout position loaded:', position);
        } catch (e) {
            debug_trunc('Failed to load popout position:', e);
        }
    }
}

// Reset popout size to CSS default
function resetPopoutSize() {
    if (!$POPOUT) return;
    
    $POPOUT.css('width', '');  // Remove inline width, use CSS default
    $POPOUT.data('user-resized', false);
    save_popout_position();
    
    toastr.info('Popout size reset to default', MODULE_NAME_FANCY);
    debug_trunc('Popout size reset to default');
}

// Update the popout toggle button appearance
function update_popout_button_state() {
    const $button = $('#ct_popout_button');
    if ($button.length === 0) return;
    
    if (POPOUT_VISIBLE) {
        $button.addClass('active');
        $button.attr('title', 'Close floating window');
    } else {
        $button.removeClass('active');
        $button.attr('title', 'Pop out settings to a floating window');
    }
}

// Add popout toggle button to the drawer header
// FIXED: Uses minimal insertion to preserve SillyTavern's drawer toggle functionality
function add_popout_button() {
    const $header = $('#context_truncator_settings .inline-drawer-header');
    if ($header.length === 0) {
        debug_trunc('Popout button: Header not found');
        return;
    }
    
    // Don't add if already exists
    if ($('#ct_popout_button').length > 0) {
        debug_trunc('Popout button: Already exists');
        return;
    }
    
    // Create the popout button
    const $button = $(`
        <i id="ct_popout_button"
           class="fa-solid fa-window-restore menu_button margin0 interactable"
           tabindex="0"
           title="Pop out settings to a floating window">
        </i>
    `);
    
    // Style the button (positioned with margin-left: auto to push to right)
    $button.css({
        'margin-left': 'auto',
        'margin-right': '10px',
        'display': 'inline-flex',
        'vertical-align': 'middle',
        'cursor': 'pointer',
        'font-size': '1em'
    });
    
    // Click handler with stopPropagation to prevent drawer toggle
    $button.on('click', (event) => {
        event.stopPropagation();
        event.preventDefault();
        togglePopout();
    });
    
    // SIMPLE INSERTION: Insert button BEFORE the chevron icon
    // This avoids detaching/restructuring anything and preserves SillyTavern's event handlers
    const $chevron = $header.find('.inline-drawer-icon');
    if ($chevron.length > 0) {
        $button.insertBefore($chevron);
    } else {
        // Fallback: append to header
        $header.append($button);
    }
    
    debug_trunc('Popout button added to header (minimal insertion)');
    
    // Intercept drawer header clicks when popout is visible
    // This allows clicking the dropdown header to close the popout and return to inline mode
    $header.on('click.ctPopout', function(event) {
        if (POPOUT_VISIBLE) {
            event.stopImmediatePropagation();
            event.preventDefault();
            closePopout();
        }
    });
}

// ==================== MEMORY DISPLAY ====================

// Update the memory display panel with current retrieved memories
function update_memory_display() {
    const $count = $('#ct_memory_count');
    const $list = $('#ct_memory_list');
    
    if (!get_settings('qdrant_enabled') || INJECTED_QDRANT_MEMORIES.length === 0) {
        $count.text('No memories retrieved');
        $list.html('<div class="ct_memory_empty">Generate a message to retrieve memories</div>');
        return;
    }

    const memories = INJECTED_QDRANT_MEMORIES;
    $count.text(`${memories.length} memor${memories.length === 1 ? 'y' : 'ies'} retrieved`);
    
    // Build memory list HTML
    let html = '';
    for (let i = 0; i < memories.length; i++) {
        const memory = memories[i];
        const score = memory.score;
        const scorePercent = (score * 100).toFixed(1);
        
        // Determine score class
        let scoreClass = 'ct_score_low';
        if (score >= 0.7) scoreClass = 'ct_score_high';
        else if (score >= 0.5) scoreClass = 'ct_score_medium';
        
        // Format text (truncate if needed)
        const text = memory.text.length > 500
            ? memory.text.substring(0, 500) + '...'
            : memory.text;
        
        html += `
            <div class="ct_memory_item">
                <div class="ct_memory_item_header">
                    <span class="ct_memory_meta">Memory ${i + 1} • Messages ${memory.firstIndex}-${memory.lastIndex}</span>
                    <span class="ct_memory_score ${scoreClass}">${scorePercent}%</span>
                </div>
                <div class="ct_memory_text">${escapeHtml(text)}</div>
            </div>
        `;
    }
    
    $list.html(html);
}

// Helper function to escape HTML
function escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

// Helper function to escape regex special characters
function escapeRegex(string) {
    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

// Validate summary output against prompt specifications (V33)
function validate_summary(summary, ctx, maxWords) {
    if (!summary || typeof summary !== 'string') {
        return { valid: false, reason: 'Empty or invalid summary' };
    }
    
    const trimmed = summary.trim();
    
    // Rule 1: Minimum length (too short = incomplete)
    if (trimmed.length < 15) {
        return { valid: false, reason: `Too short: ${trimmed.length} chars (min 15)` };
    }
    
    // Rule 2: Must start with speaker label
    const charName = ctx.name2 || 'Character';
    const userName = ctx.name1 || 'User';
    const speakerPattern = new RegExp(
        `^(${escapeRegex(charName)}:|${escapeRegex(userName)}:|Narrator:)`,
        'i'
    );
    if (!speakerPattern.test(trimmed)) {
        return { valid: false, reason: 'Missing speaker label at start' };
    }
    
    // Rule 3: Word count check
    const wordCount = trimmed.split(/\s+/).length;
    if (wordCount > maxWords) {
        return { valid: false, reason: `Too many words: ${wordCount} > ${maxWords}` };
    }
    
    // Rule 4: No forbidden patterns (thinking, reasoning)
    const forbiddenPatterns = [
        { pattern: /<think>/i, name: '<think> tag' },
        { pattern: /<\/think>/i, name: '</think> tag' },
        { pattern: /^Hmm,?/i, name: 'Hmm reasoning' },
        { pattern: /^Let me\b/i, name: 'Let me...' },
        { pattern: /^I need to\b/i, name: 'I need to...' },
        { pattern: /^First,\b/i, name: 'First,...' },
        { pattern: /^Looking at\b/i, name: 'Looking at...' },
        { pattern: /^Analyzing\b/i, name: 'Analyzing...' },
        { pattern: /^I think\b/i, name: 'I think...' },
        { pattern: /^Now,\b/i, name: 'Now,...' },
        { pattern: /\(\s*\d+\s*words?\s*\)/i, name: 'word count annotation' },
    ];
    
    for (const { pattern, name } of forbiddenPatterns) {
        if (pattern.test(trimmed)) {
            return { valid: false, reason: `Contains forbidden pattern: ${name}` };
        }
    }
    
    // Rule 5: Should be roughly one sentence (no multiple sentences)
    // Check for sentence-ending punctuation followed by space and uppercase
    const multipleSentencePattern = /[.!?]\s+[A-Z]/;
    if (multipleSentencePattern.test(trimmed)) {
        return { valid: false, reason: 'Multiple sentences detected' };
    }
    
    return { valid: true, reason: null };
}

// Summarization functionality
class SummaryQueue {
    constructor() {
        this.queue = [];
        this.active = false;
        this.stopped = false;
        this.abortController = null;  // For hard-stopping current generation
        this._currentlyGenerating = false;  // Lock to prevent parallel requests
    }
    
    async summarize(indexes) {
        if (!Array.isArray(indexes)) {
            indexes = [indexes];
        }
        
        // Reset stopped flag when starting new summarization
        this.stopped = false;
        
        for (let index of indexes) {
            this.queue.push(index);
        }
        
        // Transform button to active/stop state
        this.updateButtonState('active');
        
        if (!this.active) {
            await this.process();
        }
    }
    
    // Stop the summarization queue (hard-stop)
    stop() {
        if (!this.active) return;
        
        // Update UI immediately FIRST (before any async operations)
        this.updateButtonState('stopping');

        // Set all stop flags
        // Mark as stopped immediately to prevent new work from starting
        this.stopped = true;

        // Skip any pending rate-limit delays in process loop
        this._skipPendingDelay = true;

        // Clear queued indexes so no further messages are processed
        this.queue = [];
        
        // Abort current generation if in progress
        if (this.abortController) {
            this.abortController.abort();
            this.abortController = null;
            debug('Aborted current summarization generation');
        }
        
        debug('Summarization queue stopped by user');
    }
    
    // Transform button to active/inactive/stopping state
    updateButtonState(state) {
        const $buttons = $('#ct_summarize_all, #ct_ov_summarize');
        
        if (state === 'active') {
            $buttons.addClass('ct_active').removeClass('ct_stopping').prop('disabled', false);
            $buttons.find('i').removeClass('fa-compress fa-spinner fa-spin').addClass('fa-stop');
            $buttons.find('span').text('Stop');
            // Remove title to prevent hover tooltip during operation
            $buttons.removeAttr('title');
            // Remove any pending mouseenter handler
            $buttons.off('mouseenter.ct_title');
        } else if (state === 'stopping') {
            $buttons.addClass('ct_stopping').removeClass('ct_active').prop('disabled', true);
            $buttons.find('i').removeClass('fa-compress fa-stop').addClass('fa-spinner fa-spin');
            $buttons.find('span').text('Stopping...');
            // Remove title during stopping state
            $buttons.removeAttr('title');
        } else {
            $buttons.removeClass('ct_active ct_stopping').prop('disabled', false);
            $buttons.find('i').removeClass('fa-stop fa-spinner fa-spin').addClass('fa-compress');
            $buttons.find('span').text('Summarize All');
            // Don't restore title immediately - wait for mouse to leave and re-enter
            // This prevents tooltip flash when operation completes with mouse over button
            $buttons.off('mouseenter.ct_title').one('mouseenter.ct_title', function() {
                $(this).attr('title', 'Summarize all messages without summaries');
            });
        }
    }
    
    async process() {
        this.active = true;
        // Ensure any previous skip flag is cleared at the start of processing
        this._skipPendingDelay = false;
        
        // Update stats at start of processing
        update_summary_stats_display();
        update_overview_tab();
        
        while (this.queue.length > 0 && !this.stopped) {
            const index = this.queue.shift();
            await this.summarize_message(index);
            
            // Update stats display after each message
            update_summary_stats_display();
            update_overview_tab();

            // Rate limiting between summary requests (cancellable by stop)
            const delayMs = Number(get_settings('summary_request_delay')) || 0;
            if (delayMs > 0 && !this.stopped) {
                const start = Date.now();
                await new Promise(resolve => {
                    const checkInterval = 50; // poll interval
                    const tick = () => {
                        if (this.stopped || this._skipPendingDelay) {
                            resolve();
                            return;
                        }
                        const elapsed = Date.now() - start;
                        if (elapsed >= delayMs) {
                            resolve();
                            return;
                        }
                        setTimeout(tick, checkInterval);
                    };
                    setTimeout(tick, checkInterval);
                });
                // Reset skip flag after a controlled delay cycle
                this._skipPendingDelay = false;
            }
        }
        
        this.active = false;
        this.stopped = false;
        
        // Final update after processing completes
        update_summary_stats_display();
        update_overview_tab();
        
        // Transform button back to normal state (handles both completion and stop)
        this.updateButtonState('inactive');
    }
    
    /**
     * Cleans summary output by removing GLM-4.5 thinking blocks and extracting actual summary.
     * GLM-4.5 models wrap reasoning in <think>...</think> tags. This function:
     * 1. Detects and extracts content AFTER the last </think> tag (the actual summary)
     * 2. Removes any remaining <think> blocks that appear mid-response
     * 3. Strips orphaned tags from truncated responses
     *
     * @param {string} text - Raw model output that may contain <think> blocks
     * @returns {string} Cleaned summary text with all thinking content removed
     */
    clean_summary_output(text) {
        try {
            if (!text) return '';

            let cleaned = text.trim();

            // CRITICAL FIX: Handle responses that contain <think> anywhere (not just start)
            // Reasoning models output thinking, then the actual summary content
            const thinkStartIdx = cleaned.toLowerCase().indexOf('<think>');
            if (thinkStartIdx !== -1) {
                // Use lastIndexOf to find the LAST </think> tag (handles multiple <think> blocks)
                const closeIdx = cleaned.toLowerCase().lastIndexOf('</think>');
                if (closeIdx !== -1) {
                    // Extract content AFTER the think block (this is the actual summary)
                    const afterThink = cleaned.substring(closeIdx + 8).trim();
                    if (afterThink.length > 0) {
                        cleaned = afterThink;
                        debug_trunc(`Extracted ${afterThink.length} chars after </think> block`);
                    } else {
                        // Think block exists but no content after it
                        debug_trunc('Summary contains only <think> block with no content after, returning empty');
                        return '';
                    }
                } else {
                    // No closing tag - content was truncated mid-thinking
                    debug_trunc('Summary contains unclosed <think> block, returning empty');
                    return '';
                }
            }

            // Remove any COMPLETE <think>...</think> blocks that appear mid-response
            cleaned = cleaned.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();

            // Remove orphaned think tags (incomplete blocks from truncation)
            // First, if there's an opening <think> without closing, truncate there
            const openThink = cleaned.indexOf('<think>');
            if (openThink !== -1) {
                cleaned = cleaned.substring(0, openThink).trim();
            }
            // Then remove any stray </think> tags
            cleaned = cleaned.replace(/<\/think>/gi, '').trim();

            // Strip common markup tokens that may appear in model outputs
            cleaned = cleaned.replace(/<\/?s>/gi, '');         // Remove <s> and </s>
            cleaned = cleaned.replace(/\[\/?INST\]/gi, '');  // Remove [INST] and [/INST]

            // Normalize excessive newlines and whitespace to single spaces
            cleaned = cleaned.replace(/\r\n|\r|\n/g, ' ');
            cleaned = cleaned.replace(/\s{2,}/g, ' ').trim();

            // Remove lines that start with common prefixes like "Summary:" or "Output:"
            cleaned = cleaned.split('\n').map(l => l.trim()).filter(l => {
                const low = l.toLowerCase();
                return !(low.startsWith('summary:') || low.startsWith('output:'));
            }).join(' ');

            // Patterns that indicate reasoning/thinking content (truncate at these)
            const thinkingPatterns = [
                /\bHmm,?/i,
                /\bLet me\b/i,
                /\bLooking at\b/i,
                /\bI need to\b/i,
                /\bFirst,\b/i,
                /\bThe (user|message|speaker)\b/i,
                /\bBreaking down\b/i,
                /\bI'?ll\b/i,
                /\bI think\b/i,
                /\bNow,\b/i,
                /\bFor the\b/i,
                /\bThis (captures|covers|summarizes)\b/i,
                /\bPerfect!\b/i,
                /\bThat's\b/i,
                /\(\d+\s*words?\)/i,
                /\bI've\b/i,
                /\bAnalyzing\b/i,
                /\bThe key\b/i,
            ];

            for (const pattern of thinkingPatterns) {
                const match = cleaned.search(pattern);
                if (match !== -1) {
                    cleaned = cleaned.substring(0, match).trim();
                }
            }

            // Remove any remaining word count annotations like "(45 words)"
            cleaned = cleaned.replace(/\(\s*\d+\s*words?\s*\)/gi, '').trim();

            // If multiple sentences remain, pick the first sentence-like fragment
            const sentenceEnd = /([.!?])\s+/;
            let firstChunk = cleaned;
            if (cleaned.length > 0) {
                const parts = cleaned.split(sentenceEnd);
                if (parts && parts.length > 0) {
                    firstChunk = parts[0];
                }
            }

            // Final cleanup: remove surrounding quotes and trim
            firstChunk = firstChunk.replace(/^['\"]|['\"]$/g, '').trim();

            // Enforce maximum length (300 chars) and try to trim to end of sentence
            if (firstChunk.length > 300) {
                let truncated = firstChunk.substring(0, 300);
                try {
                    truncated = trimToEndSentence(truncated);
                } catch (e) {
                    // If trimToEndSentence fails, fallback to simple truncation
                    truncated = truncated.trim();
                }
                firstChunk = truncated;
            }

            return firstChunk;
        } catch (e) {
            console.error(`[${MODULE_NAME_FANCY}] clean_summary_output error:`, e);
            try { toastr.error(`Summary cleaning failed: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
            return '';
        }
    }
    
    // Build context block from previous message's summary for better summarization accuracy
    // This helps the model understand references and pronouns in the current message
    build_context_block(currentIndex, ctx) {
        try {
            // No context for first message
            if (currentIndex <= 0) {
                return '';
            }

            const chat = ctx.chat;

            // Look for the previous non-system message
            let prevIndex = currentIndex - 1;
            while (prevIndex >= 0 && chat[prevIndex]?.is_system) {
                prevIndex--;
            }

            if (prevIndex < 0) {
                return '';  // No previous non-system message found
            }

            const prevMessage = chat[prevIndex];
            const prevSummary = get_memory(prevMessage);

            if (!prevSummary) {
                debug(`No previous summary available for context (message ${prevIndex})`);
                return '';  // No summary available for previous message
            }

            // Build the context block with clear labeling
            const contextBlock = `[PREVIOUS MESSAGE CONTEXT - Reference Only]
            DO NOT include this section in your summary. This is background context only.
            
            Previous message summary: ${prevSummary}
            
            [END CONTEXT - Now summarize the message below]
            
            `;

            debug(`Added context from message ${prevIndex}: "${prevSummary.substring(0, 50)}..."`);
            return contextBlock;
        } catch (e) {
            console.error(`[${MODULE_NAME_FANCY}] build_context_block error:`, e);
            try { toastr.error(`Context build failed: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
            return '';
        }
    }
    
    async summarize_message(index) {
        const ctx = getContext();
        const message = ctx.chat[index];
        
        if (!message || message.is_system) {
            return;
        }
        
        // Check if stopped before starting
        if (this.stopped) {
            debug(`Summarization stopped, skipping message ${index}`);
            return;
        }
        
        debug(`Summarizing message ${index}...`);
        
        // Summarization no longer switches global connection profile;
        // it uses summary_endpoint_url (if set) or falls back to generateRaw().
        
        try {
            // Create summary prompt with placeholders
            const prompt_template = get_settings('summary_prompt');
            const max_words = get_settings('summary_max_words') || 50;
            
            // Determine the likely speaker for the prefill
            const speakerLabel = message.is_user
                ? (ctx.name1 || 'User') + ':'
                : (ctx.name2 || 'Character') + ':';
            
            // === CONTEXT INJECTION ===
            // Get previous message's summary for context (helps with references/pronouns)
            let contextBlock = '';
            try {
                const cb = this.build_context_block(index, ctx);
                contextBlock = (typeof cb === 'string') ? cb : '';
                if (!contextBlock && cb) {
                    debug(`build_context_block returned non-string for message ${index}, ignoring`);
                }
            } catch (e) {
                console.error(`[${MODULE_NAME_FANCY}] build_context_block threw:`, e);
                try { toastr.error(`Context build failed: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
                contextBlock = '';
            }

            let prompt = prompt_template
                .replace(/\{\{message\}\}/g, message.mes)
                .replace(/\{\{words\}\}/g, max_words)
                .replace(/\{\{user\}\}/g, ctx.name1 || 'User')
                .replace(/\{\{char\}\}/g, ctx.name2 || 'Character')
                .replace(/\{\{context_block\}\}/g, contextBlock);
            
            // Generate summary using configured summary endpoint (if set) or generateRaw
            try {
                // Wait for any previous generation to complete
                while (this._currentlyGenerating && !this.stopped) {
                    await new Promise(resolve => setTimeout(resolve, 100));
                }

                if (this.stopped) {
                    debug(`Summarization stopped while waiting for previous generation for message ${index}`);
                    return;
                }

                this._currentlyGenerating = true;

                // Create new AbortController for this generation
                this.abortController = new AbortController();

                // Check stopped BEFORE making the API call
                if (this.stopped) {
                    debug(`Summarization stopped before API call for message ${index}`);
                    this.abortController = null;
                    this._currentlyGenerating = false;
                    return;
                }

                debug(`Generating summary for message ${index}`);
                debug_trunc(`[${MODULE_NAME_FANCY}] Using ${get_settings('summary_endpoint_url') ? 'summary endpoint' : 'generateRaw'} for message ${index}`);

                // Prefer external summary endpoint when configured (REQ-003)
                let result = null;
                try {
                    if (get_settings('summary_endpoint_url')) {
                        // Delegate retry/backoff to call_summary_endpoint which implements exponential backoff + retries
                        result = await call_summary_endpoint(prompt, { signal: this.abortController.signal });
                    } else {
                        result = await generateRaw({
                            prompt: prompt,
                            // Note: generateRaw doesn't support abortSignal directly,
                            // but we check this.stopped before and after the call
                        });
                    }
                } catch (callErr) {
                    // If the call was aborted by the user, treat as a non-error and exit quietly
                    const wasAborted = this.stopped || (this.abortController && this.abortController.signal && this.abortController.signal.aborted) || (callErr && (callErr.name === 'AbortError' || (callErr.message && callErr.message.toLowerCase().includes('abort')) || (callErr.message && callErr.message.toLowerCase().includes('request aborted'))));

                    this.abortController = null;

                    if (wasAborted) {
                        debug(`Summarization aborted/stopped for message ${index}`);
                        return; // Don't mark message as error when user aborted
                    }

                    // Non-abort errors should be recorded on the message and surfaced
                    console.error(`[${MODULE_NAME_FANCY}] Summarization generation failed for message ${index}:`, callErr);
                    set_data(message, 'error', String(callErr));
                    try { toastr.error(`Summarization generation failed for message ${index}: ${callErr.message || String(callErr)}`, MODULE_NAME_FANCY); } catch (t) {}
                    return;
                }

                // Check if stopped during generation
                if (this.stopped) {
                    debug(`Summarization stopped during generation of message ${index}`);
                    this.abortController = null;
                    this._currentlyGenerating = false;
                    return;
                }

                this.abortController = null;

                if (result) {
                    // Normalize result to a string (handles both fetch text and structured objects)
                    const raw = (typeof result === 'string') ? result : (result?.toString?.() || '');
                    let rawSummary = raw;

                    // V33: Validation loop with max 3 attempts
                    const maxWords = get_settings('summary_max_words') || 50;
                    let validationAttempt = 0;
                    const maxValidationAttempts = 3;
                    let finalSummary = null;
                    let lastValidationReason = null;

                    while (validationAttempt < maxValidationAttempts && !this.stopped) {
                        validationAttempt++;
                        
                        // On first attempt, use the result we already have
                        // On subsequent attempts, regenerate
                        let summaryToValidate;
                        if (validationAttempt === 1) {
                            summaryToValidate = this.clean_summary_output(rawSummary);
                        } else {
                            debug_trunc(`Validation retry ${validationAttempt}/${maxValidationAttempts} for message ${index}`);
                            
                            // Regenerate with doubled tokens on retry
                            const retryTokens = (get_settings('summary_max_tokens') || 500) * 2;
                            try {
                                let retryResult;
                                if (get_settings('summary_endpoint_url')) {
                                    retryResult = await call_summary_endpoint(prompt, {
                                        signal: this.abortController?.signal,
                                        maxTokensOverride: retryTokens
                                    });
                                } else {
                                    retryResult = await generateRaw({ prompt: prompt });
                                }
                                
                                if (!retryResult) continue;
                                summaryToValidate = this.clean_summary_output(retryResult);
                            } catch (retryErr) {
                                debug_trunc(`Retry generation failed: ${retryErr.message}`);
                                continue;
                            }
                        }
                        
                        // If cleaning removed the speaker label, add it back
                        if (summaryToValidate && !summaryToValidate.includes(':')) {
                            summaryToValidate = speakerLabel + ' ' + summaryToValidate;
                        }
                        
                        // Validate the summary
                        const validation = validate_summary(summaryToValidate, ctx, maxWords);
                        
                        if (validation.valid) {
                            // Trim incomplete sentences if enabled
                            if (ctx.powerUserSettings?.trim_sentences) {
                                summaryToValidate = trimToEndSentence(summaryToValidate);
                            }
                            
                            // Final length enforcement
                            if (summaryToValidate.length > 300) {
                                summaryToValidate = summaryToValidate.substring(0, 300);
                                summaryToValidate = trimToEndSentence(summaryToValidate);
                            }
                            
                            finalSummary = summaryToValidate;
                            break;
                        } else {
                            lastValidationReason = validation.reason;
                            debug_trunc(`Validation failed (attempt ${validationAttempt}): ${validation.reason}`);
                        }
                    }

                    // Handle result
                    if (finalSummary) {
                        // Store summary
                        set_data(message, 'memory', finalSummary);
                        set_data(message, 'needs_summary', false);
                        set_data(message, 'hash', getStringHash(message.mes));
                        
                        debug(`Summarized message ${index}: "${finalSummary}"`);
                    } else {
                        // All attempts failed - mark for manual review and log if debug enabled
                        set_data(message, 'needs_manual_review', true);
                        set_data(message, 'needs_summary', true);  // Keep in pending state
                        
                        if (get_settings('debug_truncation')) {
                            const preview = message.mes.substring(0, 100) + (message.mes.length > 100 ? '...' : '');
                            console.log(`[${MODULE_NAME_FANCY}][Truncation] Summary validation failed for message ${index} after ${maxValidationAttempts} attempts`);
                            console.log(`  Last attempt reason: ${lastValidationReason}`);
                            console.log(`  Message preview: ${preview}`);
                        }
                        
                        debug(`Dropped summary for message ${index} after ${maxValidationAttempts} failed attempts`);
                    }
                }
                
                // Release lock after successful completion
                this._currentlyGenerating = false;
            } catch (e) {
                // Any unexpected errors here should be surfaced and recorded
                const aborted = this.stopped || (this.abortController && this.abortController.signal && this.abortController.signal.aborted) || (e && (e.name === 'AbortError' || (e.message && e.message.toLowerCase().includes('abort'))));
                if (aborted) {
                    debug(`Summarization aborted/stopped for message ${index}`);
                } else {
                    console.error(`[${MODULE_NAME_FANCY}]`, `Failed to summarize message ${index}:`, e);
                    set_data(message, 'error', String(e));
                    try { toastr.error(`Summarization failed for message ${index}: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (toastErr) { console.error(`[${MODULE_NAME_FANCY}] toastr error:`, toastErr); }
                }

                this.abortController = null;
                this._currentlyGenerating = false;  // Release lock on error
            }
            
            // Refresh memory after summarization (unless stopped)
            if (!this.stopped) {
                refresh_memory();
            }
        } finally {
        }
    }
}

const summaryQueue = new SummaryQueue();

// Auto-summarization
async function auto_summarize_chat() {
    const ctx = getContext();
    const chat = ctx.chat;
    
    if (!get_settings('auto_summarize')) {
        return;
    }
    
    debug('Auto-summarizing chat...');
    
    // Find messages that need summaries (respecting delay window)
    const to_summarize = [];
    const summarization_delay = get_settings('summarization_delay');
    const delay_threshold = chat.length - summarization_delay;

    for (let i = 0; i < chat.length; i++) {
        // Skip messages within delay window
        if (i >= delay_threshold) {
            continue;
        }
        if (get_data(chat[i], 'needs_summary')) {
            to_summarize.push(i);
        }
    }
    
    if (to_summarize.length > 0) {
        debug(`Auto-summarizing ${to_summarize.length} messages`);
        await summaryQueue.summarize(to_summarize);
    }
}

// Event listeners
function register_event_listeners() {
    log('Registering event listeners...');
    
    const ctx = getContext();
    const eventSource = ctx.eventSource;
    const event_types = ctx.event_types;
    
    let currentChatId = null;
    
    // Reset truncation when switching chats
    eventSource.on(event_types.CHAT_CHANGED, () => {
        const newChatId = ctx.chatId;
        if (currentChatId !== null && currentChatId !== newChatId) {
            debug('Chat switched, loading truncation index and calibration state');
            TRUNCATION_INDEX = null;
            // load_truncation_index() now loads ALL calibration state from chat_metadata:
            // - truncation_index, correction_factor
            // - calibration_state, generation_count, stable_count, retrain_count
            // - deletion_count, qdrant_token_history
            load_truncation_index();
            
            // Clear Qdrant memories for new chat (these are transient, not persisted)
            CURRENT_QDRANT_MEMORIES = [];
            CURRENT_QDRANT_INJECTION = '';
            // NOTE: QDRANT_TOKEN_HISTORY is now loaded from chat_metadata
            // by load_truncation_index() - no manual reset needed
        }
        currentChatId = newChatId;
        
        // Initialize chat snapshot for deletion/edit detection
        snapshot_chat_state();
        
        refresh_memory();
        
        // Update UI with loaded state immediately (don't wait for generation)
        update_overview_tab();
        update_calibration_ui();
        update_summary_stats_display();
    });
    
    // Smart handling of message deletions
    eventSource.on(event_types.MESSAGE_DELETED, () => {
        handle_message_deleted();
        
        // Also handle Qdrant message deletion sync
        handle_qdrant_message_deleted();
    });
    
    // Auto-summarize and auto-buffer on new character messages
    eventSource.on(event_types.CHARACTER_MESSAGE_RENDERED, (id) => {
        if (streamingProcessor && !streamingProcessor.isFinished) return;

        // Auto-summarize (delay to avoid interfering with message generation)
        setTimeout(() => auto_summarize_chat(), 500);

        // Auto-buffer for Qdrant (if enabled)
        const ctx = getContext();
        if (id !== undefined && ctx.chat[id]) {
            const message = ctx.chat[id];
            if (!message.is_system) {
                buffer_message(id, message.mes, false);  // false = character message
            }
        }

        // Vectorize delayed messages that are now outside the delay window
        vectorize_delayed_messages();

        // Delay status update to ensure itemizedPrompts is populated
        setTimeout(async () => {
            // Refresh Qdrant memories and vector statistics after each message
            if (get_settings('qdrant_enabled')) {
                try {
                    await refresh_qdrant_memories(false);
                } catch (e) {
                    debug_qdrant('Failed to refresh Qdrant memories (CHARACTER_MESSAGE_RENDERED handler):', e);
                    try { toastr.error(`Failed to refresh Qdrant memories: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
                }

                try {
                    await refresh_vector_statistics();
                } catch (e) {
                    debug_qdrant('Failed to refresh vector statistics (CHARACTER_MESSAGE_RENDERED handler):', e);
                    try { toastr.error(`Failed to refresh vector statistics: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
                }
            }

            update_status_display();
        }, 100);
    });

    // Auto-summarize and auto-buffer on new user messages
    eventSource.on(event_types.USER_MESSAGE_RENDERED, (id) => {
        // Auto-summarize (delay to avoid interfering with message generation)
        setTimeout(() => auto_summarize_chat(), 500);

        // Auto-buffer for Qdrant (if enabled)
        const ctx = getContext();
        if (id !== undefined && ctx.chat[id]) {
            const message = ctx.chat[id];
            if (!message.is_system) {
                buffer_message(id, message.mes, true);  // true = user message
            }
        }

        // Vectorize delayed messages that are now outside the delay window
        vectorize_delayed_messages();

        // Delay status update to ensure itemizedPrompts is populated
        setTimeout(async () => {
            // Refresh Qdrant memories and vector statistics after each message
            if (get_settings('qdrant_enabled')) {
                try {
                    await refresh_qdrant_memories(false);
                } catch (e) {
                    debug_qdrant('Failed to refresh Qdrant memories (USER_MESSAGE_RENDERED handler):', e);
                    try { toastr.error(`Failed to refresh Qdrant memories: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
                }
 
                try {
                    await refresh_vector_statistics();
                } catch (e) {
                    debug_qdrant('Failed to refresh vector statistics (USER_MESSAGE_RENDERED handler):', e);
                    try { toastr.error(`Failed to refresh vector statistics: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
                }
            }
 
            update_status_display();
        }, 100);
    });
}

// UI binding
function bind_setting(selector, key, type = 'text') {
    const element = $(selector);
    
    if (element.length === 0) {
        error(`No element found for selector [${selector}]`);
        return;
    }
    
    // Set initial value
    if (type === 'boolean') {
        element.prop('checked', get_settings(key));
    } else {
        element.val(get_settings(key));
    }
    
    // Listen for changes
    element.on('change', function() {
        let value;
        if (type === 'boolean') {
            value = $(this).prop('checked');
        } else if (type === 'number') {
            value = Number($(this).val());
        } else {
            value = $(this).val();
        }
        
        debug(`Setting [${key}] changed to [${value}]`);
        set_settings(key, value);
        refresh_memory();
    });
}

function initialize_ui_listeners() {
    log('Initializing UI listeners...');
    
    // ==================== TAB NAVIGATION ====================
    initialize_tab_navigation();
    
    // ==================== TRUNCATION SETTINGS ====================
    bind_setting('#ct_enabled', 'enabled', 'boolean');
    bind_setting('#ct_target_size', 'target_context_size', 'number');
    
    // Auto-limit summaries toggle (V22)
    bind_setting('#ct_auto_limit_summaries', 'auto_limit_summaries', 'boolean');
    
    // Show/hide manual slider based on auto toggle
    $('#ct_auto_limit_summaries').on('change', function() {
        const autoEnabled = $(this).prop('checked');
        $('#ct_manual_summary_limit').toggle(!autoEnabled);
        update_auto_limit_display();
    });
    
    // Manual slider (only used when auto is disabled)
    bind_range_setting('#ct_max_summary_injection_tokens', 'max_summary_injection_tokens', '#ct_max_summary_injection_tokens_display');
    
    // Initialize visibility
    $('#ct_manual_summary_limit').toggle(!get_settings('auto_limit_summaries'));
    
    // Update calculated value display
    update_auto_limit_display();
    
    // Also update when target_utilization changes
    $('#ct_target_utilization').on('change', update_auto_limit_display);
    
    bind_setting('#ct_auto_summarize', 'auto_summarize', 'boolean');
    bind_setting('#ct_summary_endpoint_url', 'summary_endpoint_url', 'text');
    bind_setting('#ct_summary_endpoint_api_key', 'summary_endpoint_api_key', 'text');
    bind_range_setting('#ct_summary_timeout', 'summary_endpoint_timeout', '#ct_summary_timeout_display');
    bind_range_setting('#ct_summary_delay', 'summary_request_delay', '#ct_summary_delay_display');
    bind_setting('#ct_summary_retries', 'summary_max_retries', 'number');

    // Per-module debug settings
    bind_setting('#ct_debug_truncation', 'debug_truncation', 'boolean');
    
    // Batch size (now a slider) - reset truncation when changed
    bind_range_setting('#ct_batch_size', 'batch_size', '#ct_batch_size_display');
    $('#ct_batch_size').off('change').on('change', function() {
        const value = Number($(this).val());
        debug(`Setting [batch_size] changed to [${value}]`);
        set_settings('batch_size', value);
        reset_truncation_index();  // Reset when batch size changes
        toastr.info('Batch size changed - truncation reset', MODULE_NAME_FANCY);
        refresh_memory();
    });
    
    // Min messages (now a slider)
    bind_range_setting('#ct_min_keep', 'min_messages_to_keep', '#ct_min_keep_display');

    // Summarization delay (new slider)
    bind_range_setting('#ct_summarization_delay', 'summarization_delay', '#ct_summarization_delay_display');
    
    // Max words per summary (now a slider)
    bind_range_setting('#ct_max_words', 'summary_max_words', '#ct_max_words_display');
    
    // Connection profile dropdown removed — summarization uses independent summary_endpoint_url
    
    // Reset All button (combines reset truncation + reset calibration)
    $('#ct_reset_all').on('click', () => {
        reset_truncation_index();
        reset_calibration();
        
        // Show status message
        const $status = $('#ct_reset_all_status');
        $status.text('✓ Reset complete - truncation and calibration cleared')
               .removeClass('ct_status_error')
               .addClass('ct_status_success')
               .show();
        
        // Auto-hide after 10 seconds
        setTimeout(() => {
            $status.fadeOut();
        }, 10000);
    });
    
    // Force Recalibrate button - resets ONLY the correction factor (not truncation index)
    $('#ct_force_recalibrate').on('click', () => {
        CHAT_TOKEN_CORRECTION_FACTOR = 1.0;
        CALIBRATION_STATE = 'INITIAL_TRAINING';
        GENERATION_COUNT = 0;
        STABLE_COUNT = 0;
        save_truncation_index();
        update_calibration_ui();
        update_overview_tab();
        toastr.info('Correction factor reset to 1.0 - will recalibrate on next generation', MODULE_NAME_FANCY);
    });
    
    // Summarize all button (toggles between start and stop)
    $('#ct_summarize_all').on('click', async () => {
        // If already active, stop
        if (summaryQueue.active) {
            summaryQueue.stop();
            return;
        }
        
        const ctx = getContext();
        const chat = ctx.chat;
        const indexes = [];
        
        for (let i = 0; i < chat.length; i++) {
            if (!chat[i].is_system && !get_memory(chat[i])) {
                indexes.push(i);
            }
        }
        
        if (indexes.length > 0) {
            await summaryQueue.summarize(indexes);
        } else {
            toastr.info('All messages already summarized', MODULE_NAME_FANCY);
        }
    });
    
    // ==================== AUTO-CALIBRATION SETTINGS ====================
    
    // Auto-calibrate toggle
    $('#ct_auto_calibrate').prop('checked', get_settings('auto_calibrate_target'));
    $('#ct_auto_calibrate').on('change', function() {
        const value = $(this).prop('checked');
        set_settings('auto_calibrate_target', value);
        update_calibration_ui();
        update_target_size_state();
        
        if (value) {
            toastr.info('Auto-calibration enabled - will start training on next generation', MODULE_NAME_FANCY);
        }
    });
    
    // Initialize target size state based on auto-calibration setting
    update_target_size_state();
    
    // Target utilization slider
    bind_range_setting_percent('#ct_target_utilization', 'target_utilization', '#ct_target_utilization_display');
    
    // Calibration tolerance slider
    bind_range_setting_percent('#ct_calibration_tolerance', 'calibration_tolerance', '#ct_calibration_tolerance_display');
    
    // Recalibrate button
    $('#ct_recalibrate').on('click', () => {
        reset_calibration();
    });
    
    // Initialize calibration UI state
    update_calibration_ui();
    
    // ==================== QDRANT SETTINGS ====================
    bind_setting('#ct_qdrant_enabled', 'qdrant_enabled', 'boolean');
    bind_setting('#ct_qdrant_url', 'qdrant_url', 'text');
    bind_setting('#ct_qdrant_collection', 'qdrant_collection', 'text');
    bind_setting('#ct_embedding_url', 'embedding_url', 'text');
    bind_setting('#ct_embedding_api_key', 'embedding_api_key', 'text');
    bind_setting('#ct_embedding_dimensions', 'embedding_dimensions', 'number');
    
    // Memory retrieval settings with range display updates
    bind_range_setting('#ct_memory_limit', 'memory_limit', '#ct_memory_limit_display');
    bind_range_setting('#ct_score_threshold', 'score_threshold', '#ct_score_threshold_display', true);
    bind_range_setting('#ct_memory_position', 'memory_position', '#ct_memory_position_display');
    bind_range_setting('#ct_retain_recent', 'retain_recent_messages', '#ct_retain_recent_display');
    bind_range_setting('#ct_qdrant_min_messages', 'qdrant_min_messages', '#ct_qdrant_min_messages_display');
    
    // Auto-save settings
    bind_setting('#ct_auto_save_memories', 'auto_save_memories', 'boolean');
    bind_setting('#ct_save_user_messages', 'save_user_messages', 'boolean');
    bind_setting('#ct_save_char_messages', 'save_char_messages', 'boolean');
    bind_setting('#ct_per_chat_collection', 'per_chat_collection', 'boolean');
    
    // Per-message vectorization settings (NEW)
    bind_range_setting('#ct_vectorization_delay', 'vectorization_delay', '#ct_vectorization_delay_display');
    bind_setting('#ct_delete_on_message_delete', 'delete_on_message_delete', 'boolean');
    bind_setting('#ct_auto_dedupe', 'auto_dedupe', 'boolean');
    
    // Qdrant action buttons
    $('#ct_qdrant_test').on('click', test_qdrant_connection);
    $('#ct_summary_endpoint_test').on('click', test_summary_endpoint);
    $('#ct_test_embedding').on('click', test_embedding);
    // Index button toggles between start and stop
    $('#ct_index_chats').on('click', () => {
        if (INDEXING_ACTIVE) {
            stop_indexing();
        } else {
            index_current_chat();
        }
    });
    $('#ct_delete_collection').on('click', delete_current_collection);
    
    // Memory panel toggle
    initialize_memory_panel_toggle();
    
    // Qdrant debug setting
    bind_setting('#ct_debug_qdrant', 'debug_qdrant', 'boolean');
    
    // ==================== SIMPLE CHUNK SETTINGS ====================
    bind_range_setting('#ct_chunk_min_size', 'chunk_min_size', '#ct_chunk_min_display');
    bind_range_setting('#ct_chunk_max_size', 'chunk_max_size', '#ct_chunk_max_display');
    bind_setting('#ct_account_qdrant_tokens', 'account_qdrant_tokens', 'boolean');
    
    // ==================== OVERVIEW TAB QUICK ACTIONS ====================
    $('#ct_ov_reset_all').on('click', () => {
        reset_truncation_index();
        reset_calibration();
        
        // Show status message
        const $status = $('#ct_ov_reset_all_status');
        $status.text('✓ Reset complete - truncation and calibration cleared')
               .removeClass('ct_status_error')
               .addClass('ct_status_success')
               .show();
        
        // Auto-hide after 10 seconds
        setTimeout(() => {
            $status.fadeOut();
        }, 10000);
    });
    
    // Overview summarize button (toggles between start and stop)
    $('#ct_ov_summarize').on('click', async () => {
        debug_trunc('Overview Summarize button clicked');

        // If already active, stop
        if (summaryQueue.active) {
            debug_trunc('SummaryQueue active - stopping');
            summaryQueue.stop();
            return;
        }

        const ctx = getContext();
        const chat = ctx.chat || [];

        if (!chat || chat.length === 0) {
            debug_trunc('No chat messages available to summarize');
            toastr.info('No messages to summarize', MODULE_NAME_FANCY);
            return;
        }

        const indexes = [];

        for (let i = 0; i < chat.length; i++) {
            if (!chat[i].is_system && !get_memory(chat[i])) {
                indexes.push(i);
            }
        }

        debug_trunc(`Found ${indexes.length} messages to summarize`);

        if (indexes.length === 0) {
            toastr.info('All messages already summarized', MODULE_NAME_FANCY);
            return;
        }

        try {
            await summaryQueue.summarize(indexes);
        } catch (e) {
            console.error(`[${MODULE_NAME_FANCY}] Summarize all failed:`, e);
            toastr.error(`Summarization failed: ${e.message || String(e)}`, MODULE_NAME_FANCY);
        }
    });
    
    // Overview memory panel toggle
    $('#ct_ov_memory_toggle').on('click', function() {
        const $content = $('#ct_ov_memory_list');
        const isExpanded = $content.is(':visible');

        if (isExpanded) {
            $content.slideUp(200);
            $(this).removeClass('expanded');
        } else {
            $content.slideDown(200);
            $(this).addClass('expanded');
        }
    });


    
    // ==================== TOKEN COUNTS TOGGLE ====================
    $('#ct_breakdown_toggle').on('click', function() {
        const $details = $('#ct_breakdown_details');
        const isExpanded = $details.is(':visible');
        
        if (isExpanded) {
            $details.slideUp(200);
            $(this).removeClass('expanded');
            $(this).find('span').text('Show Token Counts');
        } else {
            $details.slideDown(200);
            $(this).addClass('expanded');
            $(this).find('span').text('Hide Token Counts');
        }
    });
    
    // ==================== ADVANCED STATS TOGGLE (Overview) ====================
    $('#ct_advanced_toggle').on('click', function() {
        const $content = $('#ct_advanced_content');
        const isExpanded = $content.is(':visible');
        
        if (isExpanded) {
            $content.slideUp(200);
            $(this).removeClass('expanded');
        } else {
            $content.slideDown(200);
            $(this).addClass('expanded');
        }
    });
    
    // ==================== ADVANCED SETTINGS TOGGLE (Truncation Tab) ====================
    $('#ct_trunc_advanced_toggle').on('click', function() {
        const $content = $('#ct_trunc_advanced_content');
        const isExpanded = $content.is(':visible');
        
        if (isExpanded) {
            $content.slideUp(200);
            $(this).removeClass('expanded');
        } else {
            $content.slideDown(200);
            $(this).addClass('expanded');
        }
    });
    
    // ==================== ADVANCED SETTINGS TOGGLE (Qdrant Tab) ====================
    $('#ct_qdrant_advanced_toggle').on('click', function() {
        const $content = $('#ct_qdrant_advanced_content');
        const isExpanded = $content.is(':visible');
        
        if (isExpanded) {
            $content.slideUp(200);
            $(this).removeClass('expanded');
        } else {
            $content.slideDown(200);
            $(this).addClass('expanded');
        }
    });
    
    // ==================== SYNERGY TAB TOGGLES ====================
    $('#ct_synergy_info_toggle').on('click', function() {
        const $content = $('#ct_synergy_info_content');
        const isExpanded = $content.is(':visible');
        
        if (isExpanded) {
            $content.slideUp(200);
            $(this).removeClass('expanded');
        } else {
            $content.slideDown(200);
            $(this).addClass('expanded');
        }
    });
    
    $('#ct_synergy_advanced_toggle').on('click', function() {
        const $content = $('#ct_synergy_advanced_content');
        const isExpanded = $content.is(':visible');
        
        if (isExpanded) {
            $content.slideUp(200);
            $(this).removeClass('expanded');
        } else {
            $content.slideDown(200);
            $(this).addClass('expanded');
        }
    });
    
    // ==================== FOLDABLE STATS CARDS ====================
    $(document).on('click', '.ct_collapsible_toggle', function() {
        const $card = $(this).closest('.ct_collapsible');
        const isCollapsed = $card.attr('data-collapsed') === 'true';
        
        if (isCollapsed) {
            $card.attr('data-collapsed', 'false');
            $card.find('.ct_collapsible_content').slideDown(200);
        } else {
            $card.attr('data-collapsed', 'true');
            $card.find('.ct_collapsible_content').slideUp(200);
        }
    });
    
    // ==================== POPOUT FEATURE ====================
    // Add popout button to drawer header
    add_popout_button();
}

// Tab navigation functionality
function initialize_tab_navigation() {
    const $tabs = $('.ct_tab');
    const $panels = $('.ct_tab_content');
    
    $tabs.on('click', function() {
        const targetTab = $(this).data('tab');
        
        // Update active tab
        $tabs.removeClass('ct_tab_active');
        $(this).addClass('ct_tab_active');
        
        // Show target panel, hide others
        $panels.removeClass('ct_tab_content_active').hide();
        $(`.ct_tab_content[data-tab="${targetTab}"]`).addClass('ct_tab_content_active').show();
        
        debug(`Switched to tab: ${targetTab}`);
    });
    
    // Show first tab by default
    $tabs.first().addClass('ct_tab_active');
    $panels.not(':first').hide();
}

// Bind range input with display value
function bind_range_setting(selector, key, displaySelector, isFloat = false) {
    const $element = $(selector);
    const $display = $(displaySelector);
    
    if ($element.length === 0) {
        error(`No element found for selector [${selector}]`);
        return;
    }
    
    // Set initial value
    const initialValue = get_settings(key);
    $element.val(initialValue);
    $display.text(isFloat ? initialValue.toFixed(2) : initialValue);
    
    // Listen for input (live update) and change (final value)
    $element.on('input', function() {
        const value = isFloat ? parseFloat($(this).val()) : parseInt($(this).val());
        $display.text(isFloat ? value.toFixed(2) : value);
    });
    
    $element.on('change', function() {
        const value = isFloat ? parseFloat($(this).val()) : parseInt($(this).val());
        debug(`Setting [${key}] changed to [${value}]`);
        set_settings(key, value);
    });
}

// Bind range input with percentage display (for calibration settings)
function bind_range_setting_percent(selector, key, displaySelector) {
    const $element = $(selector);
    const $display = $(displaySelector);
    
    if ($element.length === 0) {
        error(`No element found for selector [${selector}]`);
        return;
    }
    
    // Set initial value
    const initialValue = get_settings(key);
    $element.val(initialValue);
    $display.text(`${Math.round(initialValue * 100)}%`);
    
    // Listen for input (live update) and change (final value)
    $element.on('input', function() {
        const value = parseFloat($(this).val());
        $display.text(`${Math.round(value * 100)}%`);
    });
    
    $element.on('change', function() {
        const value = parseFloat($(this).val());
        debug(`Setting [${key}] changed to [${value}]`);
        set_settings(key, value);
    });
}

// Bind range input with float display (for V10 settings like temporal_midpoint)
function bind_range_setting_float(selector, key, displaySelector, decimals = 2) {
    const $element = $(selector);
    const $display = $(displaySelector);
    
    if ($element.length === 0) {
        error(`No element found for selector [${selector}]`);
        return;
    }
    
    // Set initial value
    const initialValue = get_settings(key);
    $element.val(initialValue);
    $display.text(initialValue.toFixed(decimals));
    
    // Listen for input (live update) and change (final value)
    $element.on('input', function() {
        const value = parseFloat($(this).val());
        $display.text(value.toFixed(decimals));
    });
    
    $element.on('change', function() {
        const value = parseFloat($(this).val());
        debug(`Setting [${key}] changed to [${value}]`);
        set_settings(key, value);
    });
}

// Initialize memory panel toggle
function initialize_memory_panel_toggle() {
    const $header = $('#ct_memory_panel_toggle');
    const $content = $('#ct_memory_list');
    
    $header.on('click', function() {
        const isExpanded = $content.is(':visible');
        
        if (isExpanded) {
            $content.slideUp(200);
            $header.removeClass('expanded');
        } else {
            $content.slideDown(200);
            $header.addClass('expanded');
        }
    });
}

// ==================== QDRANT UTILITY FUNCTIONS ====================

// Test Qdrant connection
async function test_qdrant_connection() {
    const url = get_settings('qdrant_url');
    const $status = $('#ct_qdrant_status');
    
    if (!url) {
        $status.removeClass().addClass('ct_status_message ct_status_error').text('No Qdrant URL configured');
        return;
    }
    
    $status.removeClass().addClass('ct_status_message ct_status_info').text('Testing connection...');
    
    try {
        const response = await fetch(`${url}/collections`, {
            method: 'GET',
            headers: { 'Content-Type': 'application/json' }
        });
        
        if (response.ok) {
            const data = await response.json();
            const collectionCount = data.result?.collections?.length || 0;
            $status.removeClass().addClass('ct_status_message ct_status_success')
                .text(`Connected! ${collectionCount} collection(s) found`);
            debug_qdrant(`Connection successful: ${collectionCount} collections`);
            
            // VIS-003: Auto-clear status after 10 seconds
            setTimeout(() => {
                $status.text('').removeClass('ct_status_success ct_status_error ct_status_info');
            }, 10000);
        } else {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
    } catch (e) {
        $status.removeClass().addClass('ct_status_message ct_status_error')
            .text(`Connection failed: ${e.message}`);
        error('Qdrant connection test failed:', e);
        
        // VIS-003: Auto-clear status after 10 seconds
        setTimeout(() => {
            $status.text('').removeClass('ct_status_success ct_status_error ct_status_info');
        }, 10000);
    }
}
// Test Summary Endpoint (OpenAI-compatible)
async function test_summary_endpoint() {
    const $status = $('#ct_summary_endpoint_status');
    const $button = $('#ct_summary_endpoint_test');

    // Read values from UI or fallback to settings
    const urlInput = ($('#ct_summary_endpoint_url').length ? $('#ct_summary_endpoint_url').val() : null) || get_settings('summary_endpoint_url');
    const apiKeyInput = ($('#ct_summary_endpoint_api_key').length ? $('#ct_summary_endpoint_api_key').val() : null) || get_settings('summary_endpoint_api_key');

    if (!urlInput) {
        $status.removeClass().addClass('ct_status_message ct_status_error').text('Invalid URL');
        return;
    }

    let parsedUrl;
    try {
        parsedUrl = new URL(urlInput);
    } catch (e) {
        $status.removeClass().addClass('ct_status_message ct_status_error').text('Invalid URL');
        return;
    }

    $status.removeClass().addClass('ct_status_message ct_status_info').text('Testing connection...');
    $button.prop('disabled', true);

    // We'll reuse the same parsing logic used by call_summary_endpoint to ensure parity
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), 10000);

    const headers = { 'Content-Type': 'application/json' };
    if (apiKeyInput) headers['Authorization'] = `Bearer ${apiKeyInput}`;

    const body = JSON.stringify({
        model: 'gpt-3.5-turbo',
        messages: [
            { role: 'system', content: 'You are a helpful assistant. Respond directly without showing your thinking process.' },
            { role: 'user', content: 'Confirm you are connected with a friendly greeting. Maximum 3 words.' }
        ],
        max_tokens: 20,
        temperature: 0.7
    });

    try {
        const resp = await fetch(parsedUrl.toString(), {
            method: 'POST',
            headers: headers,
            body: body,
            signal: controller.signal
        });

        clearTimeout(timeout);

        if (resp.ok) {
            let dataText = '';
            try {
                const data = await resp.json();
                dataText = extract_model_content(data);
            } catch (e) {
                // Not JSON or unexpected shape
                const text = await resp.text();
                dataText = text;
            }

            if (dataText && dataText.toString().trim().length > 0) {
                const sample = dataText.toString().trim().substring(0, 120);
                $status.removeClass().addClass('ct_status_message ct_status_success').text(`Connected! Sample reply: "${sample}"`);
            } else {
                $status.removeClass().addClass('ct_status_message ct_status_error').text('Unexpected response shape');
            }

        } else if (resp.status === 401 || resp.status === 403) {
            $status.removeClass().addClass('ct_status_message ct_status_error').text(`Authentication failed (HTTP ${resp.status})`);
        } else {
            $status.removeClass().addClass('ct_status_message ct_status_error').text(`Connection failed: HTTP ${resp.status}: ${resp.statusText}`);
        }
    } catch (e) {
        clearTimeout(timeout);
        if (e.name === 'AbortError') {
            $status.removeClass().addClass('ct_status_message ct_status_error').text('Connection timed out (10s)');
        } else if (e instanceof TypeError) {
            $status.removeClass().addClass('ct_status_message ct_status_error').text(`Network/CORS error: ${e.message}`);
        } else {
            $status.removeClass().addClass('ct_status_message ct_status_error').text(`Error: ${e.message || String(e)}`);
        }
    } finally {
        $button.prop('disabled', false);
    }
}


// Call summary endpoint (OpenAI-compatible). Returns the raw model output as string.
function extract_model_content(data) {
    if (!data) return '';
    return (data?.choices && data.choices[0]) ? (data.choices[0].message?.content || data.choices[0].text) : (data?.text || '');
}

async function call_summary_endpoint(prompt, options = {}) {
    const { signal = null, attempt = 0, maxTokensOverride = null } = options;
    const url = get_settings('summary_endpoint_url');
    const apiKey = get_settings('summary_endpoint_api_key');
    const maxRetries = get_settings('summary_max_retries') || 3;

    if (!url) throw new Error('No summary endpoint configured');

    let parsed;
    try { parsed = new URL(url); } catch (e) { throw new Error('Invalid summary endpoint URL'); }

    const controller = new AbortController();
    // NO TIMEOUT - wait indefinitely for LLM response
    // AbortController is ONLY used for user-initiated Stop button
    
    // Link external abort signal (from Stop button) to our controller
    if (signal) {
        signal.addEventListener('abort', () => controller.abort());
    }

    const headers = { 'Content-Type': 'application/json' };
    if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;

    const body = JSON.stringify({
        model: 'gpt-3.5-turbo',
        messages: [
            { role: 'system', content: 'You are a helpful assistant. Respond directly without showing your thinking process.' },
            { role: 'user', content: prompt }
        ],
        max_tokens: maxTokensOverride || get_settings('summary_max_tokens') || 800,
        temperature: 0.2,
        thinking: { type: 'disabled' }  // GLM-4: Disable deep thinking mode to prevent <think> blocks
        // NOTE: The `thinking` parameter is GLM-4 specific but harmless for other APIs.
        // - GLM-4 models via TabbyAPI: Prevents ~400+ token <think> blocks from consuming token budget
        // - OpenAI/Anthropic/other APIs: Silently ignored (not part of their API spec)
        // - Fallback defense: clean_summary_output() strips any <think> blocks that slip through
        // Without this, GLM-4.5 Air exhausts the 800 token budget with thinking, truncating summaries mid-sentence
    });

    try {
        const resp = await fetch(parsed.toString(), {
            method: 'POST',
            headers,
            body,
            signal: controller.signal
        });

        // Handle retryable errors
        if (resp.status === 503 || resp.status === 429) {
            if (attempt < maxRetries) {
                const backoffMs = Math.pow(2, attempt) * 1000 + Math.random() * 500;
                debug_trunc(`HTTP ${resp.status}, retry ${attempt + 1}/${maxRetries} after ${Math.round(backoffMs)}ms`);
                
                await new Promise(resolve => setTimeout(resolve, backoffMs));
                
                // Check if aborted during backoff
                if (signal?.aborted) {
                    throw new Error('Aborted during retry backoff');
                }
                
                return call_summary_endpoint(prompt, { signal, attempt: attempt + 1 });
            }
            const text = await resp.text();
            throw new Error(`HTTP ${resp.status} after ${maxRetries} retries: ${text}`);
        }

        if (!resp.ok) {
            const text = await resp.text();
            throw new Error(`HTTP ${resp.status}: ${text}`);
        }

        let data;
        try { data = await resp.json(); } catch (e) {
            const txt = await resp.text();
            return txt;
        }

        const content = extract_model_content(data);
        
        // Retry on empty response
        if (!content || content.trim().length === 0) {
            if (attempt < maxRetries) {
                const backoffMs = Math.pow(2, attempt) * 1000 + Math.random() * 500;
                debug_trunc(`Empty response, retry ${attempt + 1}/${maxRetries} after ${Math.round(backoffMs)}ms`);
                await new Promise(resolve => setTimeout(resolve, backoffMs));
                if (signal?.aborted) throw new Error('Aborted during retry backoff');
                return call_summary_endpoint(prompt, { signal, attempt: attempt + 1 });
            }
            throw new Error('Empty response after max retries');
        }
        
        return content;
        
    } catch (e) {
        if (e.name === 'AbortError') {
            throw new Error('Request aborted by user');
        }
        if (e instanceof TypeError) throw new Error(`Network/CORS error: ${e.message}`);
        throw e;
    }
}


// Test embedding endpoint
async function test_embedding() {
    const url = get_settings('embedding_url');
    const apiKey = get_settings('embedding_api_key');
    const $status = $('#ct_embedding_status');
    
    if (!url) {
        $status.removeClass().addClass('ct_status_message ct_status_error').text('No embedding URL configured');
        return;
    }
    
    $status.removeClass().addClass('ct_status_message ct_status_info').text('Testing embedding...');
    
    try {
        const testText = 'This is a test sentence for embedding generation.';
        const embedding = await generate_embedding(testText);
        
        if (embedding && embedding.length > 0) {
            // Store detected dimensions
            set_settings('embedding_dimensions', embedding.length);
            // Also update the UI field
            $('#ct_embedding_dimensions').val(embedding.length);
            $status.removeClass().addClass('ct_status_message ct_status_success')
                .text(`Success! Dimensions: ${embedding.length}`);
            debug_qdrant(`Embedding test successful: ${embedding.length} dimensions`);
            
            // VIS-003: Auto-clear status after 10 seconds
            setTimeout(() => {
                $status.text('').removeClass('ct_status_success ct_status_error ct_status_info');
            }, 10000);
        } else {
            throw new Error('Empty embedding returned');
        }
    } catch (e) {
        $status.removeClass().addClass('ct_status_message ct_status_error')
            .text(`Embedding failed: ${e.message}`);
        error('Embedding test failed:', e);
        
        // VIS-003: Auto-clear status after 10 seconds
        setTimeout(() => {
            $status.text('').removeClass('ct_status_success ct_status_error ct_status_info');
        }, 10000);
    }
}

// Generate embedding using KoboldCPP/local endpoint (OpenAI-compatible format)
async function generate_embedding(text, signal = null) {
    const url = get_settings('embedding_url');
    const apiKey = get_settings('embedding_api_key');
    
    if (!url) {
        throw new Error('No embedding URL configured');
    }
    
    const headers = {
        'Content-Type': 'application/json'
    };
    
    if (apiKey) {
        headers['Authorization'] = `Bearer ${apiKey}`;
    }
    
    const MAX_RETRIES = 3;
    const BASE_DELAY = 1000; // 1 second
    
    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
        try {
            // OpenAI-compatible embedding request format
            const response = await fetch(url, {
                method: 'POST',
                headers: headers,
                body: JSON.stringify({
                    input: text,
                    model: 'text-embedding'  // KoboldCPP ignores this but it's required for format
                }),
                signal: signal
            });
            
            if (!response.ok) {
                // Check if it's a retryable error (503 Service Unavailable)
                if (response.status === 503 && attempt < MAX_RETRIES) {
                    const delay = BASE_DELAY * Math.pow(2, attempt);
                    debug_qdrant(`Embedding endpoint 503 error, retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})`);
                    await new Promise((resolve, reject) => {
                        const timeout = setTimeout(resolve, delay);
                        if (signal) {
                            signal.addEventListener('abort', () => {
                                clearTimeout(timeout);
                                reject(new DOMException('Aborted', 'AbortError'));
                            }, { once: true });
                        }
                    });
                    continue;
                }
                
                const errorText = await response.text();
                throw new Error(`HTTP ${response.status}: ${errorText}`);
            }
            
            const data = await response.json();
            
            // OpenAI format: data.data[0].embedding
            if (data.data && data.data[0] && data.data[0].embedding) {
                return data.data[0].embedding;
            }
            
            // Alternative format: data.embedding
            if (data.embedding) {
                return data.embedding;
            }
            
            throw new Error('Unexpected embedding response format');
        } catch (err) {
            // Check for abort
            if (err.name === 'AbortError') {
                throw err;
            }
            
            // Network errors or other exceptions
            if (attempt < MAX_RETRIES && (err.message.includes('fetch') || err.message.includes('network'))) {
                const delay = BASE_DELAY * Math.pow(2, attempt);
                debug_qdrant(`Embedding generation error: ${err.message}, retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})`);
                await new Promise((resolve, reject) => {
                    const timeout = setTimeout(resolve, delay);
                    if (signal) {
                        signal.addEventListener('abort', () => {
                            clearTimeout(timeout);
                            reject(new DOMException('Aborted', 'AbortError'));
                        }, { once: true });
                    }
                });
                continue;
            }
            throw err; // Final attempt failed or non-retryable error
        }
    }
}

// Get the current collection name (may include chat-specific suffix)
function get_current_collection_name() {
    const baseCollection = get_settings('qdrant_collection');
    
    if (!get_settings('per_chat_collection')) {
        return baseCollection;
    }
    
    // Get chat identifier for per-chat collections
    const ctx = getContext();
    if (!ctx.chatId) {
        return baseCollection;
    }
    
    // Create a safe collection name from chat ID
    const chatSuffix = ctx.chatId.replace(/[^a-zA-Z0-9_-]/g, '_');
    return `${baseCollection}_${chatSuffix}`;
}

// Clear memories for current chat
async function clear_current_memories() {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    
    if (!url || !collection) {
        toastr.error('Qdrant not configured', MODULE_NAME_FANCY);
        return;
    }
    
    const confirmed = confirm(`Clear all memories from collection "${collection}"?\n\nThis will delete all stored vectors but keep the collection.`);
    if (!confirmed) return;
    
    try {
        // Delete all points in the collection by deleting and recreating
        const dimensions = get_settings('embedding_dimensions');
        
        if (!dimensions) {
            toastr.error('Unknown embedding dimensions. Run embedding test first.', MODULE_NAME_FANCY);
            return;
        }
        
        // Delete collection
        await fetch(`${url}/collections/${collection}`, {
            method: 'DELETE'
        });
        
        // Recreate collection
        await fetch(`${url}/collections/${collection}`, {
            method: 'PUT',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                vectors: {
                    size: dimensions,
                    distance: 'Cosine'
                }
            })
        });
        
        toastr.success(`Cleared memories from "${collection}"`, MODULE_NAME_FANCY);
        debug_qdrant(`Cleared all memories from collection: ${collection}`);
    } catch (e) {
        toastr.error(`Failed to clear memories: ${e.message}`, MODULE_NAME_FANCY);
        error('Failed to clear memories:', e);
    }
}

// Stop indexing function
function stop_indexing() {
    if (!INDEXING_ACTIVE) return;
    
    INDEXING_STOPPED = true;
    
    // Abort any in-progress async operations
    if (INDEXING_ABORT_CONTROLLER) {
        INDEXING_ABORT_CONTROLLER.abort();
        INDEXING_ABORT_CONTROLLER = null;
    }
    
    // Update button to show stopping state
    update_indexing_button_state('stopping');
    
    debug_qdrant('Indexing stop requested by user');
    toastr.warning('Stopping indexing...', MODULE_NAME_FANCY);
}

// Transform indexing button to active/inactive state
function update_indexing_button_state(state) {
    const $button = $('#ct_index_chats');
    
    if (state === 'active') {
        $button.addClass('ct_active').removeClass('ct_stopping').prop('disabled', false);
        $button.find('i').removeClass('fa-database fa-spinner fa-spin').addClass('fa-stop');
        $button.find('span').text('Stop');
        $button.removeAttr('title');
        $button.off('mouseenter.ct_title');
    } else if (state === 'stopping') {
        $button.addClass('ct_stopping').removeClass('ct_active').prop('disabled', true);
        $button.find('i').removeClass('fa-database fa-stop').addClass('fa-spinner fa-spin');
        $button.find('span').text('Stopping...');
        $button.removeAttr('title');
    } else {
        // inactive
        $button.removeClass('ct_active ct_stopping').prop('disabled', false);
        $button.find('i').removeClass('fa-stop fa-spinner fa-spin').addClass('fa-database');
        $button.find('span').text('Index Chat');
        $button.off('mouseenter.ct_title').one('mouseenter.ct_title', function() {
            $(this).attr('title', 'Index all messages from current chat');
        });
    }
}

// Delete current collection entirely
async function delete_current_collection() {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    const $status = $('#ct_delete_collection_status');
    
    if (!url || !collection) {
        $status.text('✗ Qdrant not configured')
               .removeClass('ct_status_success')
               .addClass('ct_status_error')
               .show();
        setTimeout(() => { $status.fadeOut(); }, 10000);
        return;
    }
    
    const confirmed = confirm(`DELETE collection "${collection}"?\n\nThis action cannot be undone!`);
    if (!confirmed) return;
    
    try {
        const response = await fetch(`${url}/collections/${collection}`, {
            method: 'DELETE'
        });
        
        if (response.ok) {
            $status.text(`✓ Deleted collection "${collection}"`)
                   .removeClass('ct_status_error')
                   .addClass('ct_status_success')
                   .show();
            setTimeout(() => { $status.fadeOut(); }, 10000);
            debug_qdrant(`Deleted collection: ${collection}`);
        } else {
            throw new Error(`HTTP ${response.status}`);
        }
    } catch (e) {
        $status.text(`✗ Failed to delete collection: ${e.message}`)
               .removeClass('ct_status_success')
               .addClass('ct_status_error')
               .show();
        setTimeout(() => { $status.fadeOut(); }, 10000);
        error('Failed to delete collection:', e);
    }
}

// ==================== MEMORY BUFFER AND CHUNKING ====================

// ==================== SIMPLE MESSAGE BUFFER (st-qdrant-memory style) ====================

let messageBuffer = [];
let lastMessageTime = 0;
let chunkTimer = null;

function getUserDisplayName() {
    const ctx = getContext();
    return ctx.name1 || 'User';
}

function formatDateForChunk(timestamp) {
    try {
        const dateObj = new Date(timestamp);
        if (isNaN(dateObj.getTime())) {
            throw new Error('Invalid date');
        }
        return dateObj.toISOString().split('T')[0]; // YYYY-MM-DD format
    } catch (e) {
        console.warn(`[${MODULE_NAME_FANCY}] Error formatting date:`, e);
        return new Date().toISOString().split('T')[0];
    }
}

function createChunkFromBuffer() {
    if (messageBuffer.length === 0) return null;

    const ctx = getContext();
    let chunkText = '';
    const speakers = new Set();
    const messageIds = [];
    let oldestTimestamp = Infinity;

    // Build chunk text with speaker labels
    messageBuffer.forEach((msg) => {
        const speaker = msg.isUser ? getUserDisplayName() : (ctx.name2 || 'Character');
        speakers.add(speaker);
        messageIds.push(msg.messageId);

        // Track oldest message timestamp for proper temporal filtering
        if (msg.timestamp && msg.timestamp < oldestTimestamp) {
            oldestTimestamp = msg.timestamp;
        }

        const line = `${speaker}: ${msg.text}\n`;
        chunkText += line;
    });

    // Format date prefix
    let finalText = chunkText.trim();
    const dateStr = formatDateForChunk(oldestTimestamp);
    finalText = `[${dateStr}]\n${finalText}`;

    return {
        text: finalText,
        speakers: Array.from(speakers),
        messageIds: messageIds,
        messageCount: messageBuffer.length,
        timestamp: oldestTimestamp,  // Use oldest message time, not indexing time
        chatId: ctx.chatId,
        characterName: ctx.name2 || 'Unknown'
    };
}

async function processMessageBuffer() {
    if (!get_settings('qdrant_enabled')) return;
    if (messageBuffer.length === 0) return;
    
    const chunk = createChunkFromBuffer();
    if (!chunk) return;
    
    try {
        await saveChunkToQdrant(chunk);
        debug_qdrant(`Saved chunk with ${chunk.messageCount} messages`);
    } catch (e) {
        error('Failed to save chunk:', e);
    }
    
    // Clear buffer after saving
    messageBuffer = [];
}

function buffer_message(index, text, isUser) {
    if (!get_settings('qdrant_enabled')) return;
    if (!get_settings('auto_save_memories')) return;
    if (!text || text.length < 5) return;
    
    // Check if we should save this type of message
    if (isUser && !get_settings('save_user_messages')) return;
    if (!isUser && !get_settings('save_char_messages')) return;
    
    const ctx = getContext();
    const messageId = `${ctx.name2}_${Date.now()}_${index}`;

    // Get message timestamp from chat
    const message = ctx.chat[index];
    const msgTimestamp = message?.send_date ? normalizeTimestamp(message.send_date) : Date.now();

    // Check if message already in buffer
    const existingIndex = messageBuffer.findIndex((msg) => msg.messageId === messageId);
    if (existingIndex !== -1) {
        // Update if longer text
        if (text.length > messageBuffer[existingIndex].text.length) {
            messageBuffer[existingIndex].text = text;
        }
        return;
    }

    messageBuffer.push({
        text: text,
        characterName: ctx.name2 || 'Character',
        isUser: isUser,
        messageId: messageId,
        index: index,
        timestamp: msgTimestamp
    });
    
    lastMessageTime = Date.now();
    
    // Calculate current buffer size
    let bufferSize = 0;
    messageBuffer.forEach((msg) => {
        bufferSize += msg.text.length + (msg.characterName?.length || 0) + 4;
    });
    
    debug_qdrant(`Buffer: ${messageBuffer.length} messages, ${bufferSize} chars`);
    
    // Clear existing timer
    if (chunkTimer) {
        clearTimeout(chunkTimer);
    }
    
    const minSize = get_settings('chunk_min_size') || 1200;
    const maxSize = get_settings('chunk_max_size') || 1500;
    const timeout = get_settings('chunk_timeout') || 30000;
    
    // If buffer exceeds max size, process it now
    if (bufferSize >= maxSize) {
        debug_qdrant(`Buffer reached max size (${bufferSize}), processing chunk`);
        processMessageBuffer();
    }
    // If buffer is at least min size, set a short timer
    else if (bufferSize >= minSize) {
        chunkTimer = setTimeout(() => {
            debug_qdrant(`Buffer reached min size and timeout, processing chunk`);
            processMessageBuffer();
        }, 5000);
    }
    // Otherwise, set a longer timer
    else {
        chunkTimer = setTimeout(() => {
            debug_qdrant(`Buffer timeout reached, processing chunk`);
            processMessageBuffer();
        }, timeout);
    }
}

// Save chunk to Qdrant (simplified - matches st-qdrant-memory)
async function saveChunkToQdrant(chunk) {
    if (!get_settings('qdrant_enabled')) {
        debug_qdrant('Qdrant disabled, skipping chunk storage');
        return;
    }
    
    debug_qdrant(`Saving chunk: ${chunk.messageCount} messages, ${chunk.text.length} chars`);
    
    try {
        // Generate embedding for the chunk
        const embedding = await generate_embedding(chunk.text);
        
        if (!embedding || embedding.length === 0) {
            throw new Error('Failed to generate embedding');
        }
        
        // Ensure collection exists
        await ensure_collection_exists();
        
        // Create point for Qdrant with simplified payload
        const point = {
            id: generate_point_id(),
            vector: embedding,
            payload: {
                text: chunk.text,
                speakers: chunk.speakers.join(', '),
                messageCount: chunk.messageCount,
                timestamp: chunk.timestamp,
                messageIds: chunk.messageIds.join(','),
                isChunk: true,
                chatId: chunk.chatId,
                characterName: chunk.characterName
            }
        };
        
        // Upsert to Qdrant
        await upsert_points([point]);
        
        debug_qdrant(`Stored chunk with ${chunk.messageCount} messages to Qdrant`);
        
    } catch (e) {
        error('Failed to save chunk:', e);
        throw e;
    }
}

// Generate a unique point ID (must be UUID format for Qdrant)
function generate_point_id() {
    // Generate a valid UUID v4
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        const r = Math.random() * 16 | 0;
        const v = c === 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
    });
}

// ==================== QDRANT STORAGE FUNCTIONS ====================

// Ensure collection exists with correct configuration and payload indexes
async function ensure_collection_exists() {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    const dimensions = get_settings('embedding_dimensions');
    
    if (!url || !collection) {
        throw new Error('Qdrant not configured');
    }
    
    if (!dimensions) {
        throw new Error('Embedding dimensions not set. Run embedding test first.');
    }
    
    try {
        // Check if collection exists
        const checkResponse = await fetch(`${url}/collections/${collection}`, {
            method: 'GET'
        });
        
        if (checkResponse.ok) {
            debug_qdrant(`Collection ${collection} already exists`);
            // Ensure payload indexes exist (idempotent operation)
            await ensure_payload_indexes(collection);
            return;
        }
        
        // Create collection
        debug_qdrant(`Creating collection ${collection} with ${dimensions} dimensions`);
        
        const createResponse = await fetch(`${url}/collections/${collection}`, {
            method: 'PUT',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                vectors: {
                    size: dimensions,
                    distance: 'Cosine'
                }
            })
        });
        
        if (!createResponse.ok) {
            const errorText = await createResponse.text();
            throw new Error(`Failed to create collection: ${errorText}`);
        }
        
        debug_qdrant(`Created collection ${collection}`);
        
        // Create payload indexes for efficient filtering
        await ensure_payload_indexes(collection);
        
    } catch (e) {
        error('Failed to ensure collection exists:', e);
        throw e;
    }
}

// Create payload indexes for efficient filtering (V10 enhancement)
async function ensure_payload_indexes(collection) {
    const url = get_settings('qdrant_url');
    
    const indexes = [
        { field: 'chat_id', schema: { type: 'keyword', is_tenant: true } },  // Primary filter, tenant-optimized
        { field: 'timestamp', schema: { type: 'integer' } },  // For temporal sorting/filtering
        { field: 'message_hash', schema: { type: 'keyword' } },  // For deduplication
        { field: 'is_user', schema: { type: 'bool' } },  // For filtering by message type
        { field: 'chunk_id', schema: { type: 'keyword' } },  // For chunk-based operations
    ];
    
    for (const index of indexes) {
        try {
            const response = await fetch(`${url}/collections/${collection}/index`, {
                method: 'PUT',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    field_name: index.field,
                    field_schema: index.schema
                })
            });
            
            if (response.ok) {
                debug_qdrant(`Created/verified index for ${index.field}`);
            } else {
                // Index may already exist with different schema - that's okay
                const errorText = await response.text();
                debug_qdrant(`Index ${index.field}: ${errorText}`);
            }
        } catch (e) {
            debug_qdrant(`Failed to create index for ${index.field}:`, e);
            // Non-fatal - continue with other indexes
        }
    }
}

// Upsert points to Qdrant
async function upsert_points(points) {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    
    if (!url || !collection) {
        throw new Error('Qdrant not configured');
    }
    
    const MAX_RETRIES = 3;
    const BASE_DELAY = 1000; // 1 second
    
    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
        try {
            const response = await fetch(`${url}/collections/${collection}/points`, {
                method: 'PUT',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    points: points
                })
            });
            
            if (!response.ok) {
                // Check if it's a retryable error (503 Service Unavailable)
                if (response.status === 503 && attempt < MAX_RETRIES) {
                    const delay = BASE_DELAY * Math.pow(2, attempt);
                    debug_qdrant(`Qdrant 503 error on upsert, retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})`);
                    await new Promise(resolve => setTimeout(resolve, delay));
                    continue;
                }
                
                const errorText = await response.text();
                throw new Error(`Failed to upsert points: ${errorText}`);
            }
            
            debug_qdrant(`Upserted ${points.length} points to ${collection}`);
            return; // Success
        } catch (err) {
            // Network errors or other exceptions
            if (attempt < MAX_RETRIES) {
                const delay = BASE_DELAY * Math.pow(2, attempt);
                debug_qdrant(`Qdrant upsert error: ${err.message}, retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})`);
                await new Promise(resolve => setTimeout(resolve, delay));
                continue;
            }
            throw err; // Final attempt failed
        }
    }
}

// Simple temporal filtering (like st-qdrant-memory)
// Excludes recent messages based on retain_recent_messages setting
async function search_with_simple_temporal(collection, queryEmbedding, limit, scoreThreshold) {
    // Calculate timestamp threshold to exclude recent messages
    const ctx = getContext();
    const chat = ctx.chat || [];
    const retainRecent = get_settings('retain_recent_messages');
    let timestampThreshold = 0;

    if (retainRecent > 0 && chat.length > retainRecent) {
        const retainIndex = chat.length - retainRecent;
        const retainMessage = chat[retainIndex];
        if (retainMessage && retainMessage.send_date) {
            timestampThreshold = normalizeTimestamp(retainMessage.send_date);
            debug_qdrant(`Simple temporal filter: excluding messages newer than ${timestampThreshold}`);
        }
    }

    // Use standard search with timestamp filtering
    return await search_standard_with_filter(
        collection, queryEmbedding, limit, scoreThreshold, timestampThreshold
    );
}

// Simple, reliable search limit calculation (V13 - simplified like st-qdrant-memory)
function calculateSearchLimit(limit) {
    // Fixed 1.5x overfetch for temporal re-ranking - much more reasonable than 3x
    // This gives us enough results for deduplication without excessive data
    return Math.ceil(limit * 1.5);
}

// Simplified memory search with reliable temporal filtering (V13 - like st-qdrant-memory)
async function search_memories(queryText, limit = null, scoreThreshold = null) {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();

    if (!url || !collection) {
        throw new Error('Qdrant not configured');
    }

    limit = limit ?? get_settings('memory_limit');
    scoreThreshold = scoreThreshold ?? get_settings('score_threshold');

    // Calculate timestamp threshold to exclude recent messages
    const ctx = getContext();
    const chat = ctx.chat || [];
    const retainRecent = get_settings('retain_recent_messages');
    let timestampThreshold = 0;

    if (retainRecent > 0 && chat.length > retainRecent) {
        const retainIndex = chat.length - retainRecent;
        const retainMessage = chat[retainIndex];
        if (retainMessage && retainMessage.send_date) {
            timestampThreshold = normalizeTimestamp(retainMessage.send_date);
            debug_qdrant(`Excluding messages newer than timestamp: ${timestampThreshold}`);
        }
    }

    debug_qdrant(`Search - limit:${limit}, retainRecent:${retainRecent}`);

    try {
        // Generate embedding for query
        const queryEmbedding = await generate_embedding(queryText);

        if (!queryEmbedding || queryEmbedding.length === 0) {
            throw new Error('Failed to generate query embedding');
        }

        // Simple standard search with timestamp filtering
        let results = await search_standard_with_filter(
            collection, queryEmbedding, limit, scoreThreshold, timestampThreshold
        );

        debug_qdrant(`Search returned ${results.length} results`);

        // Remove duplicates if enabled
        if (get_settings('auto_dedupe') && results.length > 0) {
            results = deduplicate_results_simple(results);
        }

        // Limit to requested count
        results = results.slice(0, limit);

        // Map results to memory format
        const memories = results.map(r => map_search_result_to_memory(r));

        // Track retrieval statistics
        track_retrieval_stats(memories, 0);

        return memories;

    } catch (e) {
        error('Failed to search memories:', e);
        throw e;
    }
}

// Standard search without temporal scoring
async function search_standard(collection, queryEmbedding, limit, scoreThreshold) {
    const url = get_settings('qdrant_url');

    const searchBody = {
        vector: queryEmbedding,
        limit: limit,
        score_threshold: scoreThreshold,
        with_payload: true
    };

    const response = await fetch(`${url}/collections/${collection}/points/search`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(searchBody)
    });

    if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Search failed: ${errorText}`);
    }

    const data = await response.json();
    return data.result || [];
}

// Standard search with timestamp filtering (excludes recent messages)
async function search_standard_with_filter(collection, queryEmbedding, limit, scoreThreshold, timestampThreshold) {
    const url = get_settings('qdrant_url');

    const searchBody = {
        vector: queryEmbedding,
        limit: limit,
        score_threshold: scoreThreshold,
        with_payload: true
    };

    // Only apply timestamp filter if threshold is meaningful
    // This allows retrieval even with legacy data that has wrong timestamps
    if (timestampThreshold > 0) {
        searchBody.filter = {
            must: [
                {
                    key: 'timestamp',
                    range: {
                        lt: timestampThreshold
                    }
                }
            ]
        };
    }

    const response = await fetch(`${url}/collections/${collection}/points/search`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(searchBody)
    });

    if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Search failed: ${errorText}`);
    }

    const data = await response.json();
    return data.result || [];
}

// Map a raw search result to a standardized memory object
function map_search_result_to_memory(r) {
    const payload = r.payload;
    
    // V10 chunk format (new)
    if (payload.chunk_id !== undefined) {
        return {
            id: r.id,
            score: r.score,
            originalScore: r.originalScore,  // May be present from client-side temporal scoring
            temporalMultiplier: r.temporalMultiplier,
            text: payload.text,
            chunkId: payload.chunk_id,
            messageIndexes: payload.message_indexes || [],
            firstIndex: payload.first_index,
            lastIndex: payload.last_index,
            timestamp: payload.timestamp,
            characterName: payload.character_name,
            chatId: payload.chat_id,
            datePrefix: payload.date_prefix,
            isChunk: true
        };
    }
    
    // Per-message format (message_index singular)
    if (payload.message_index !== undefined) {
        return {
            id: r.id,
            score: r.score,
            originalScore: r.originalScore,
            temporalMultiplier: r.temporalMultiplier,
            text: payload.text,
            messageIndex: payload.message_index,
            messageHash: payload.message_hash,
            isUser: payload.is_user,
            firstIndex: payload.message_index,
            lastIndex: payload.message_index,
            timestamp: payload.timestamp,
            characterName: payload.character_name,
            chatId: payload.chat_id,
            isChunk: false
        };
    }
    
    // Old chunked format (message_indexes plural, no chunk_id)
    return {
        id: r.id,
        score: r.score,
        originalScore: r.originalScore,
        temporalMultiplier: r.temporalMultiplier,
        text: payload.text,
        messageIndexes: payload.message_indexes,
        firstIndex: payload.first_index,
        lastIndex: payload.last_index,
        timestamp: payload.timestamp,
        characterName: payload.character_name,
        chatId: payload.chat_id,
        isChunk: true
    };
}

// Get collection info
async function get_collection_info() {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    
    if (!url || !collection) {
        return null;
    }
    
    try {
        const response = await fetch(`${url}/collections/${collection}`, {
            method: 'GET'
        });
        
        if (!response.ok) {
            return null;
        }
        
        const data = await response.json();
        return data.result;
        
    } catch (e) {
        debug('Failed to get collection info:', e);
        return null;
    }
}

// Buffer a message for chunked vectorization
function buffer_message_for_chunking(index, text, isUser, message) {
    // REQ-005 FIX: Ensure message hash is computed for deduplication
    if (message && message.mes && !get_data(message, 'hash')) {
        set_data(message, 'hash', getStringHash(message.mes));
    }
    
    // Check vectorization delay
    const ctx = getContext();
    const delay = get_settings('vectorization_delay');
    if (index >= ctx.chat.length - delay) {
        debug_qdrant(`Message ${index} within delay window (${delay}), skipping buffer`);
        return;
    }
    
    // Check if already chunked
    if (get_data(message, 'chunked')) {
        debug_qdrant(`Message ${index} already chunked, skipping`);
        return;
    }
    
    // Create message hash for deduplication
    const messageHash = getStringHash(text);
    
    // Add to chunk buffer
    chunkBuffer.add({
        index: index,
        text: text,
        isUser: isUser,
        timestamp: Date.now(),
        hash: messageHash
    });
    
    debug_qdrant(`Buffered message ${index} for chunking (buffer: ${chunkBuffer.getState().messageCount} messages)`);
}

// Vectorize a single message directly (legacy/fallback mode)
async function vectorize_message(index, text, isUser) {
    if (!get_settings('qdrant_enabled')) return;
    if (!get_settings('auto_save_memories')) return;
    if (isUser && !get_settings('save_user_messages')) return;
    if (!isUser && !get_settings('save_char_messages')) return;
    
    const ctx = getContext();
    const message = ctx.chat[index];
    
    if (!message) {
        debug_qdrant(`Message ${index} not found, skipping vectorization`);
        return;
    }
    
    // Check if already vectorized or chunked
    if (get_data(message, 'vectorized') || get_data(message, 'chunked')) {
        debug_qdrant(`Message ${index} already vectorized/chunked, skipping`);
        return;
    }
    
    // Check vectorization delay
    const delay = get_settings('vectorization_delay');
    if (index >= ctx.chat.length - delay) {
        debug_qdrant(`Message ${index} within delay window (${delay}), skipping`);
        return;
    }
    
    // SYNERGY: Use summary if enabled and available
    let textToVectorize = text;
    if (get_settings('use_summaries_for_qdrant')) {
        const summary = get_memory(message);
        if (summary) {
            textToVectorize = summary;
        }
    }
    
    try {
        // Generate embedding
        const embedding = await generate_embedding(textToVectorize);
        
        if (!embedding || embedding.length === 0) {
            throw new Error('Failed to generate embedding');
        }
        
        // Ensure collection exists
        await ensure_collection_exists();
        
        // Create message hash for deduplication and deletion
        const messageHash = getStringHash(text);
        
        // Create point with V10 payload structure
        const point = {
            id: generate_point_id(),
            vector: embedding,
            payload: {
                message_index: index,
                message_hash: messageHash,
                text: textToVectorize,
                is_user: isUser,
                timestamp: Date.now(),
                chat_id: ctx.chatId,
                character_name: ctx.name2 || 'Unknown',
                is_chunk: false  // V10: Mark as per-message, not chunked
            }
        };
        
        // Upsert to Qdrant
        await upsert_points([point]);
        
        // Mark as vectorized
        set_data(message, 'vectorized', true);
        set_data(message, 'vector_hash', messageHash);
        
        debug_qdrant(`Vectorized message ${index} (hash: ${messageHash})`);
        
    } catch (e) {
        error(`Failed to vectorize message ${index}:`, e);
    }
}

// Vectorize/chunk messages that were previously skipped due to delay
async function vectorize_delayed_messages() {
    if (!get_settings('qdrant_enabled')) return;
    if (!get_settings('auto_save_memories')) return;
    
    const ctx = getContext();
    const chat = ctx.chat;
    
    if (!chat || chat.length === 0) return;
    
    const delay = get_settings('vectorization_delay');
    const threshold = chat.length - delay;
    const useChunking = get_settings('enable_chunked_vectorization');
    
    debug_qdrant(`Checking for delayed messages (threshold: ${threshold}, chunking: ${useChunking})`);
    
    let processed = 0;
    
    for (let i = 0; i < threshold; i++) {
        const message = chat[i];
        
        // Skip system messages
        if (message.is_system) continue;
        
        // Skip already processed
        if (get_data(message, 'vectorized') || get_data(message, 'chunked')) continue;
        
        // Check message type settings
        if (message.is_user && !get_settings('save_user_messages')) continue;
        if (!message.is_user && !get_settings('save_char_messages')) continue;
        
        if (useChunking) {
            // Buffer for chunking
            buffer_message_for_chunking(i, message.mes, message.is_user, message);
        } else {
            // Direct vectorization
            await vectorize_message(i, message.mes, message.is_user);
        }
        processed++;
    }
    
    // If using chunking, force flush any remaining buffer after processing delayed messages
    if (useChunking && processed > 0) {
        const chunk = chunkBuffer.forceFlush();
        if (chunk) {
            try {
                await process_and_store_chunk(chunk);
            } catch (e) {
                error('Failed to process final chunk:', e);
            }
        }
    }
    
    if (processed > 0) {
        debug_qdrant(`Processed ${processed} delayed messages (chunking: ${useChunking})`);
    }
}

// ==================== VECTOR STATISTICS FUNCTIONS (V11) ====================

// Create a simple text-based score distribution chart
function create_score_distribution_chart(scores) {
    if (!scores || scores.length === 0) return '--';

    // Categorize scores: high (>=0.8), medium (0.5-0.8), low (<0.5)
    const categories = { high: 0, medium: 0, low: 0 };
    for (const score of scores) {
        if (score >= 0.8) categories.high++;
        else if (score >= 0.5) categories.medium++;
        else categories.low++;
    }

    // Create a simple bar chart (max 10 characters)
    const total = scores.length;
    const highBars = Math.round((categories.high / total) * 10);
    const mediumBars = Math.round((categories.medium / total) * 10);
    const lowBars = Math.round((categories.low / total) * 10);

    const chart = '█'.repeat(highBars) + '░'.repeat(mediumBars) + '▒'.repeat(lowBars);

    return `${chart} (${categories.high}/${categories.medium}/${categories.low})`;
}

// Get detailed collection statistics
async function get_vector_statistics() {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();

    if (!url || !collection) {
        return null;
    }

    try {
        // Get collection info
        const infoResponse = await fetch(`${url}/collections/${collection}`, {
            method: 'GET'
        });

        if (!infoResponse.ok) {
            return null;
        }

        const info = await infoResponse.json();
        const totalPoints = info.result?.points_count || 0;

        // Count chunks vs single messages (optional, may be slow for large collections)
        let chunkCount = 0;
        let singleCount = 0;

        // Use scroll API to count by type (paginated)
        // This is optional - can skip if collection is large
        if (totalPoints < 10000) {
            const scrollResponse = await fetch(`${url}/collections/${collection}/points/scroll`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    limit: totalPoints,
                    with_payload: ['is_chunk']
                })
            });

            if (scrollResponse.ok) {
                const scrollData = await scrollResponse.json();
                for (const point of scrollData.result?.points || []) {
                    if (point.payload?.is_chunk) {
                        chunkCount++;
                    } else {
                        singleCount++;
                    }
                }
            }
        }

        return {
            collectionName: collection,
            totalPoints: totalPoints,
            chunkPoints: chunkCount,
            singlePoints: singleCount
        };

    } catch (e) {
        error('Failed to get vector statistics:', e);
        return null;
    }
}

// Track retrieval statistics after memory search
function track_retrieval_stats(memories, duplicateCount) {
    VECTOR_STATS.retrievedCount = memories.length;
    VECTOR_STATS.duplicatesRemoved = duplicateCount;
    VECTOR_STATS.lastRetrieval = Date.now();

    if (memories.length > 0) {
        const scores = memories.map(m => m.score);
        VECTOR_STATS.scores = scores; // Store for distribution chart
        VECTOR_STATS.avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
        VECTOR_STATS.minScore = Math.min(...scores);
        VECTOR_STATS.maxScore = Math.max(...scores);
    } else {
        VECTOR_STATS.scores = [];
        VECTOR_STATS.avgScore = 0;
        VECTOR_STATS.minScore = 0;
        VECTOR_STATS.maxScore = 0;
    }
}

// Update vector statistics display
async function update_vector_stats_display() {
    // Show/hide card based on Qdrant enabled setting
    const isQdrantEnabled = get_settings('qdrant_enabled');
    $('#ct_vector_memory_card').toggle(isQdrantEnabled);

    if (!isQdrantEnabled) {
        return; // Don't update stats if disabled
    }

    // Update health indicator
    const $health = $('#ct_ov_vector_health');
    if (VECTOR_STATS.connected) {
        $health.text('✓ Connected').removeClass('ct_health_unknown ct_health_error').addClass('ct_health_good');
    } else {
        $health.text('✗ Error').removeClass('ct_health_unknown ct_health_good').addClass('ct_health_error');
    }

    // Update stored count
    if (VECTOR_STATS.totalPoints > 0) {
        const label = VECTOR_STATS.chunkPoints > 0 ? 'chunks' : 'points';
        $('#ct_ov_vector_stored').text(`${VECTOR_STATS.totalPoints} ${label}`);
    } else {
        $('#ct_ov_vector_stored').text('-- chunks');
    }

    // Update retrieved stats (display elements removed per REQ-007/REQ-008)
    // Statistics are still tracked in VECTOR_STATS for internal use

    // Update buffer state
    const bufferCount = messageBuffer.length;
    $('#ct_ov_vector_buffer').text(`${bufferCount} msgs`);

    // Update advanced stats
    $('#ct_ov_collection_name').text(VECTOR_STATS.collectionName || '--');
    $('#ct_ov_total_points').text(VECTOR_STATS.totalPoints || '--');
    $('#ct_ov_chunk_points').text(VECTOR_STATS.chunkPoints || '--');
    $('#ct_ov_single_points').text(VECTOR_STATS.singlePoints || '--');
    $('#ct_ov_temporal_mode').text(VECTOR_STATS.temporalMode === 'server' ? 'Server-side' :
                                   VECTOR_STATS.temporalMode === 'client' ? 'Client-side' : '--');
    $('#ct_ov_avg_score').text(VECTOR_STATS.avgScore > 0 ? VECTOR_STATS.avgScore.toFixed(3) : '--');
    $('#ct_ov_score_range').text(VECTOR_STATS.minScore > 0 ?
                                  `${VECTOR_STATS.minScore.toFixed(2)} - ${VECTOR_STATS.maxScore.toFixed(2)}` : '--');
    $('#ct_ov_deduped').text(VECTOR_STATS.duplicatesRemoved > 0 ? VECTOR_STATS.duplicatesRemoved : '0');
}

// Refresh vector statistics (called manually via button)
async function refresh_vector_statistics() {
    try {
        // Test connection
        const url = get_settings('qdrant_url');
        if (url) {
            const response = await fetch(`${url}/collections`, { method: 'GET' });
            VECTOR_STATS.connected = response.ok;
        } else {
            VECTOR_STATS.connected = false;
        }

        // Get collection stats
        if (VECTOR_STATS.connected) {
            const stats = await get_vector_statistics();
            if (stats) {
                VECTOR_STATS.collectionName = stats.collectionName;
                VECTOR_STATS.totalPoints = stats.totalPoints;
                VECTOR_STATS.chunkPoints = stats.chunkPoints;
                VECTOR_STATS.singlePoints = stats.singlePoints;
                VECTOR_STATS.lastCollectionCheck = Date.now();
            }
        }

    } catch (e) {
        VECTOR_STATS.connected = false;
        VECTOR_STATS.lastConnectionError = String(e);
        debug_qdrant('Vector statistics refresh failed:', e);
    }
}

// ==================== DUPLICATE DETECTION ====================

// Detect and remove duplicate entries in search results
function detect_duplicates(results) {
    const seenHashes = new Map();  // hash -> { result, timestamp }
    const uniqueResults = [];
    const duplicateIds = [];

    for (const result of results) {
        const hash = result.payload.message_hash;
        const timestamp = result.payload.timestamp;

        // Skip results without hash (old format)
        if (!hash) {
            uniqueResults.push(result);
            continue;
        }

        if (seenHashes.has(hash)) {
            const existing = seenHashes.get(hash);

            if (timestamp > existing.timestamp) {
                // Current is newer = duplicate, delete it
                duplicateIds.push(result.id);
                debug_qdrant(`Duplicate found: ${result.id} is newer copy of ${existing.result.id}`);
            } else {
                // Current is older = keep it, delete existing
                duplicateIds.push(existing.result.id);
                const idx = uniqueResults.indexOf(existing.result);
                if (idx >= 0) {
                    uniqueResults[idx] = result;
                }
                seenHashes.set(hash, { result, timestamp });
                debug_qdrant(`Duplicate found: ${existing.result.id} is newer copy of ${result.id}`);
            }
        } else {
            seenHashes.set(hash, { result, timestamp });
            uniqueResults.push(result);
        }
    }

    return { uniqueResults, duplicateIds };
}

// Simple deduplication function that removes duplicates and returns unique results
function deduplicate_results_simple(results) {
    if (!results || results.length === 0) {
        return results;
    }

    const { uniqueResults, duplicateIds } = detect_duplicates(results);

    // Async cleanup of duplicates (fire-and-forget)
    if (duplicateIds.length > 0) {
        delete_points_by_ids(duplicateIds).catch(e => {
            debug_qdrant('Failed to delete duplicate points:', e);
        });
    }

    return uniqueResults;
}

// Delete points by their IDs
async function delete_points_by_ids(pointIds) {
    if (!pointIds || pointIds.length === 0) return;
    
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    
    if (!url || !collection) {
        throw new Error('Qdrant not configured');
    }
    
    const response = await fetch(`${url}/collections/${collection}/points/delete`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            points: pointIds
        })
    });
    
    if (!response.ok) {
        throw new Error(`Delete failed: ${await response.text()}`);
    }
    
    debug_qdrant(`Deleted ${pointIds.length} duplicate points`);
}

// ==================== MESSAGE DELETION SYNC ====================

// Delete Qdrant point by message hash
async function delete_qdrant_point_by_hash(messageHash) {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    const ctx = getContext();
    
    if (!url || !collection) {
        throw new Error('Qdrant not configured');
    }
    
    const response = await fetch(`${url}/collections/${collection}/points/delete`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            filter: {
                must: [
                    { key: "message_hash", match: { value: messageHash } },
                    { key: "chat_id", match: { value: ctx.chatId } }
                ]
            }
        })
    });
    
    if (response.ok) {
        debug_qdrant(`Deleted Qdrant point for hash ${messageHash}`);
        return true;
    } else {
        error(`Failed to delete Qdrant point: ${await response.text()}`);
        return false;
    }
}

// Handle Qdrant deletion when messages are deleted in SillyTavern
async function handle_qdrant_message_deleted() {
    if (!get_settings('qdrant_enabled')) return;
    if (!get_settings('delete_on_message_delete')) return;
    
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    
    if (!url || !collection) return;
    
    const ctx = getContext();
    const chat = ctx.chat;
    const currentLength = chat ? chat.length : 0;
    
    // Use PRE_SNAPSHOT to determine which messages were deleted
    const deletedCount = PRE_SNAPSHOT_CHAT_LENGTH - currentLength;
    if (deletedCount <= 0) return;
    
    debug_qdrant(`Handling Qdrant deletion for ${deletedCount} message(s)`);
    
    try {
        // Find deleted message hashes by comparing snapshots
        const deletedHashes = [];
        const deletedIndexes = [];
        
        for (const [index, hash] of PRE_SNAPSHOT_CHAT_HASHES) {
            // Check if this index/hash is still in current chat
            const currentMessage = chat[index];
            const currentHash = currentMessage ? compute_message_hash(currentMessage) : null;
            
            if (!currentHash || currentHash !== hash) {
                deletedHashes.push(hash);
                deletedIndexes.push(index);
            }
        }
        
        if (deletedHashes.length === 0) return;
        
        debug_qdrant(`Found ${deletedHashes.length} deleted message hashes:`, deletedHashes);
        
        // Delete per-message vectors by hash
        for (const hash of deletedHashes) {
            await delete_vectors_by_hash(url, collection, hash);
        }
        
        // Delete chunks containing any deleted message indexes
        const reQueueIndexes = await delete_chunks_containing_indexes(url, collection, deletedIndexes);
        
        // Re-queue surviving messages from deleted chunks for re-vectorization
        // REQ-004 FIX: Re-queue affected messages for vectorization
        if (reQueueIndexes.length > 0) {
            debug_qdrant(`Re-queuing ${reQueueIndexes.length} messages for vectorization`);
            for (const idx of reQueueIndexes) {
                if (chat[idx] && !chat[idx].is_system) {
                    const msg = chat[idx];
                    buffer_message_for_chunking(idx, msg.mes, msg.is_user, msg);
                }
            }
        }
        
    } catch (e) {
        error('Failed to delete Qdrant vectors:', e);
        // Don't block message deletion on Qdrant errors
    }
}

// Delete vectors matching a message hash
async function delete_vectors_by_hash(url, collection, hash) {
    try {
        const ctx = getContext();
        const response = await fetch(`${url}/collections/${collection}/points/delete`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                filter: {
                    must: [
                        { key: 'message_hash', match: { value: hash } },
                        { key: 'chat_id', match: { value: ctx.chatId } }
                    ]
                }
            })
        });
        
        if (response.ok) {
            debug_qdrant(`Deleted vectors with hash: ${hash}`);
        }
    } catch (e) {
        debug_qdrant(`Failed to delete vectors by hash: ${e.message}`);
    }
}

// Delete chunks containing any of the given message indexes, return indexes to re-queue
async function delete_chunks_containing_indexes(url, collection, deletedIndexes) {
    const reQueueIndexes = [];
    
    try {
        const ctx = getContext();
        
        // Search for chunks containing any deleted index
        for (const deletedIndex of deletedIndexes) {
            // Find chunks where message_indexes array contains deletedIndex
            const searchResponse = await fetch(`${url}/collections/${collection}/points/scroll`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    filter: {
                        must: [
                            { key: 'message_indexes', match: { any: [deletedIndex] } },
                            { key: 'chat_id', match: { value: ctx.chatId } }
                        ]
                    },
                    limit: 100,
                    with_payload: true
                })
            });
            
            if (!searchResponse.ok) continue;
            
            const data = await searchResponse.json();
            const points = data.result?.points || [];
            
            for (const point of points) {
                const chunkIndexes = point.payload?.message_indexes || [];
                
                // Collect indexes that should be re-queued (not the deleted one)
                for (const idx of chunkIndexes) {
                    if (!deletedIndexes.includes(idx) && !reQueueIndexes.includes(idx)) {
                        reQueueIndexes.push(idx);
                    }
                }
                
                // Delete the chunk
                await fetch(`${url}/collections/${collection}/points/delete`, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        points: [point.id]
                    })
                });
                
                debug_qdrant(`Deleted chunk ${point.id} containing message ${deletedIndex}`);
            }
        }
    } catch (e) {
        debug_qdrant(`Failed to delete chunks: ${e.message}`);
    }
    
    return reQueueIndexes;
}

// Check if a message hash already exists in Qdrant
async function check_hash_exists_in_qdrant(messageHash) {
    const url = get_settings('qdrant_url');
    const collection = get_current_collection_name();
    const ctx = getContext();

    if (!url || !collection) return false;

    try {
        const response = await fetch(`${url}/collections/${collection}/points/scroll`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                filter: {
                    must: [
                        { key: 'message_hash', match: { value: messageHash } },
                        { key: 'chat_id', match: { value: ctx.chatId } }
                    ]
                },
                limit: 1,
                with_payload: false
            })
        });

        if (!response.ok) return false;

        const data = await response.json();
        return (data.result?.points?.length || 0) > 0;
    } catch (e) {
        debug_qdrant(`Hash check failed: ${e.message}`);
        return false;
    }
}

// Index entire current chat (matches Summarize All pattern exactly)
async function index_current_chat() {
    // If already active, stop (toggle behavior - matches Summarize All)
    if (INDEXING_ACTIVE) {
        stop_indexing();
        return;
    }

    const ctx = getContext();
    const chat = ctx.chat;

    if (!get_settings('qdrant_enabled')) {
        toastr.error('Qdrant is not enabled', MODULE_NAME_FANCY);
        return;
    }

    if (!chat || chat.length === 0) {
        toastr.info('No messages to index', MODULE_NAME_FANCY);
        return;
    }

    // Set indexing state
    INDEXING_ACTIVE = true;
    INDEXING_STOPPED = false;
    INDEXING_ABORT_CONTROLLER = new AbortController();

    update_indexing_button_state('active');

    // Helper for inline status updates
    const $indexStatus = $('#ct_index_status');
    const showIndexStatus = (message, isError = false) => {
        $indexStatus
            .removeClass('ct_status_success ct_status_error')
            .addClass(isError ? 'ct_status_error' : 'ct_status_success')
            .text(message)
            .show();

        // Auto-clear after 10 seconds
        setTimeout(() => {
            $indexStatus.fadeOut();
        }, 10000);
    };

    debug_qdrant(`Starting chat indexing - ${chat.length} messages`);

    // BUG-004 FIX: Check if collection exists and has data
    // If collection is empty/missing, clear stale vectorized/chunked flags
    const collectionInfo = await get_collection_info();
    const collectionEmpty = !collectionInfo || (collectionInfo.points_count === 0);

    if (collectionEmpty) {
        debug_qdrant('Collection empty or missing - clearing stale vectorization flags');
        for (let i = 0; i < chat.length; i++) {
            const msg = chat[i];
            if (get_data(msg, 'vectorized') || get_data(msg, 'chunked')) {
                set_data(msg, 'vectorized', false);
                set_data(msg, 'chunked', false);
            }
        }
    }

    let processed = 0;
    let skipped = 0;

    try {
        // Clear existing buffer to start fresh
        messageBuffer = [];

        // Iterate through ALL messages (like Summarize All)
        for (let i = 0; i < chat.length; i++) {
            // Check if stopped
            if (INDEXING_STOPPED) {
                debug_qdrant(`Indexing stopped at message ${i}`);
                break;
            }

            const message = chat[i];

            // Skip system messages
            if (message.is_system) {
                continue;
            }

            // Skip already vectorized/chunked messages
            if (get_data(message, 'vectorized') || get_data(message, 'chunked')) {
                skipped++;
                continue;
            }

            // REQ-001: Check Qdrant for existing hash (authoritative deduplication)
            const messageHash = getStringHash(message.mes);
            try {
                const existsInQdrant = await check_hash_exists_in_qdrant(messageHash);
                if (existsInQdrant) {
                    // Mark local flag to avoid re-checking next time
                    set_data(message, 'chunked', true);
                    skipped++;
                    debug_qdrant(`Skipping message ${i} - already in Qdrant (hash: ${messageHash})`);
                    continue;
                }
            } catch (e) {
                debug_qdrant(`Hash check error for message ${i}: ${e.message}`);
                // Continue with indexing on error (fail-open)
            }

            // Check message type settings
            if (message.is_user && !get_settings('save_user_messages')) {
                continue;
            }
            if (!message.is_user && !get_settings('save_char_messages')) {
                continue;
            }

            // Add to buffer
            const messageId = `${ctx.name2}_${Date.now()}_${i}`;
            // Get message timestamp from chat
            const msgTimestamp = message?.send_date ? normalizeTimestamp(message.send_date) : Date.now();

            messageBuffer.push({
                text: message.mes,
                characterName: ctx.name2 || 'Character',
                isUser: message.is_user,
                messageId: messageId,
                index: i,
                timestamp: msgTimestamp
            });

            processed++;

            // Check buffer size and process if needed
            let bufferSize = 0;
            messageBuffer.forEach((msg) => {
                bufferSize += msg.text.length + (msg.characterName?.length || 0) + 4;
            });

            const maxSize = get_settings('chunk_max_size') || 1500;
            if (bufferSize >= maxSize) {
                try {
                    await processMessageBuffer();
                    // Mark processed messages as chunked
                    for (const bufferedMsg of messageBuffer) {
                        if (chat[bufferedMsg.index]) {
                            set_data(chat[bufferedMsg.index], 'chunked', true);
                        }
                    }
                } catch (e) {
                    debug_qdrant(`Failed to process chunk: ${e.message}`);
                }
            }
        }

        // Process any remaining buffer
        if (messageBuffer.length > 0 && !INDEXING_STOPPED) {
            try {
                await processMessageBuffer();
            } catch (e) {
                debug_qdrant(`Failed to process final chunk: ${e.message}`);
            }
        }

        const wasStopped = INDEXING_STOPPED;
        debug_qdrant(`Indexing ${wasStopped ? 'stopped' : 'completed'}: ${processed} processed, ${skipped} skipped`);

        if (wasStopped) {
            showIndexStatus('⚠ Indexing stopped', false);
        } else if (processed === 0 && skipped > 0) {
            showIndexStatus(`✓ All ${skipped} messages already indexed`, false);
        } else if (processed > 0) {
            showIndexStatus(`✓ Indexed ${processed} messages (${skipped} skipped)`, false);
        } else {
            showIndexStatus('ℹ No messages to index', false);
        }

    } catch (e) {
        error('Failed to index chat:', e);
        toastr.error(`Indexing failed: ${e.message}`, MODULE_NAME_FANCY);
    } finally {
        // Reset indexing state
        INDEXING_ACTIVE = false;
        INDEXING_STOPPED = false;
        INDEXING_ABORT_CONTROLLER = null;
        messageBuffer = [];  // Clear buffer

        update_indexing_button_state('inactive');
    }
}

// ==================== MEMORY RETRIEVAL AND INJECTION ====================

// Retrieve relevant memories for current context
async function retrieve_relevant_memories() {
    if (!get_settings('qdrant_enabled')) {
        return [];
    }
    
    const ctx = getContext();
    const chat = ctx.chat;
    
    if (!chat || chat.length === 0) {
        return [];
    }
    
    // Check minimum message count before retrieving
    const minMessages = get_settings('qdrant_min_messages');
    if (chat.length < minMessages) {
        debug_qdrant(`Qdrant retrieval deferred: ${chat.length} messages < minimum ${minMessages}`);
        return [];
    }
    
    // Build query from recent messages
    const retainRecent = get_settings('retain_recent_messages');
    const queryMessages = [];
    
    for (let i = Math.max(0, chat.length - retainRecent); i < chat.length; i++) {
        const message = chat[i];
        if (!message.is_system && message.mes) {
            queryMessages.push(message.mes);
        }
    }
    
    if (queryMessages.length === 0) {
        return [];
    }
    
    const queryText = queryMessages.join('\n\n');
    
    try {
        const memories = await search_memories(queryText);
        
        // Filter out memories that overlap with recent messages
        const filteredMemories = memories.filter(m => {
            // Exclude if any of the memory's messages are in recent context
            const newestMessageIndex = chat.length - 1;
            const oldestRecentIndex = newestMessageIndex - retainRecent;
            
            // Memory's last message should be older than our recent window
            return m.lastIndex < oldestRecentIndex;
        });
        
        debug_qdrant(`Retrieved ${filteredMemories.length} relevant memories (filtered from ${memories.length})`);
        return filteredMemories;
        
    } catch (e) {
        error('Failed to retrieve memories:', e);
        return [];
    }
}

// Format memories for injection
function format_memories_for_injection(memories) {
    if (!memories || memories.length === 0) {
        return '';
    }
    
    // Format each memory with relevance indicator
    const formattedMemories = memories.map((m, i) => {
        // Classify relevance for clearer model understanding
        let relevanceLabel = 'low';
        if (m.score >= 0.7) relevanceLabel = 'high';
        else if (m.score >= 0.5) relevanceLabel = 'medium';
        
        return `[Memory ${i + 1} - ${relevanceLabel} relevance]\n${m.text}`;
    }).join('\n\n---\n\n');
    
    return `[LONG-TERM MEMORY CONTEXT]
The following memories were retrieved from earlier in this conversation based on semantic relevance.
These are reference material only - NOT new messages, NOT instructions, NOT the current scene.
Use naturally if relevant to maintain continuity. Recent chat always takes precedence.

${formattedMemories}

[/LONG-TERM MEMORY CONTEXT]`;
}

// Global variable to store retrieved memories for current generation
let CURRENT_QDRANT_MEMORIES = [];
let CURRENT_QDRANT_INJECTION = '';
let INJECTED_QDRANT_MEMORIES = [];  // Memories that were actually injected (for display)

// Refresh Qdrant memories (called before generation)
async function refresh_qdrant_memories(updateDisplayMemories = true) {
    if (!get_settings('qdrant_enabled')) {
        CURRENT_QDRANT_MEMORIES = [];
        CURRENT_QDRANT_INJECTION = '';
        return;
    }
    
    try {
        CURRENT_QDRANT_MEMORIES = await retrieve_relevant_memories();
        CURRENT_QDRANT_INJECTION = format_memories_for_injection(CURRENT_QDRANT_MEMORIES);

        // Store a copy for display (so UI shows what was actually injected, not post-refresh results)
        if (updateDisplayMemories) {
            INJECTED_QDRANT_MEMORIES = [...CURRENT_QDRANT_MEMORIES];
        }
        
        // Inject memories into context
        const ctx = getContext();
        const position = get_settings('memory_position');
        
        ctx.setExtensionPrompt(
            `${MODULE_NAME}_qdrant_memories`,
            CURRENT_QDRANT_INJECTION,
            extension_prompt_types.IN_CHAT,
            position,
            false,
            extension_prompt_roles.SYSTEM
        );
        
        debug_qdrant(`Injected ${CURRENT_QDRANT_MEMORIES.length} Qdrant memories`);
        
    } catch (e) {
        error('Failed to refresh Qdrant memories:', e);
        CURRENT_QDRANT_MEMORIES = [];
        CURRENT_QDRANT_INJECTION = '';
    }
}

// Get token count of current Qdrant injection (for synergy token accounting)
function get_qdrant_injection_tokens() {
    if (!CURRENT_QDRANT_INJECTION) {
        return 0;
    }
    return count_tokens(CURRENT_QDRANT_INJECTION);
}

// Load settings HTML
async function load_settings_html() {
    log('Loading settings HTML...');
    
    const module_dir = new URL(import.meta.url).pathname;
    const settings_path = module_dir.substring(0, module_dir.lastIndexOf('/')) + '/settings.html';
    
    await $.get(settings_path).then(response => {
        $('#extensions_settings2').append(response);
        log('Settings HTML loaded');
    }).catch(err => {
        error('Failed to load settings HTML:', err);
    });
}

// Entry point
jQuery(async function () {
    log('Loading Context Truncator with Summarization...');
    
    // Initialize
    initialize_settings();
    
    // Load settings HTML
    await load_settings_html();
    
    // Setup UI and events
    initialize_ui_listeners();
    register_event_listeners();

    // Ensure truncation index and calibration state are loaded on initial startup
    // so the Overview and Calibration UIs reflect persisted chat metadata immediately
    try {
        load_truncation_index();
        snapshot_chat_state();

        // Refresh memory prompts and UI to reflect loaded state
        refresh_memory();
        update_calibration_ui();
        update_summary_stats_display();
        update_overview_tab();

        // Refresh vector statistics asynchronously if Qdrant is enabled
        if (get_settings('qdrant_enabled')) {
            try {
                await refresh_vector_statistics();
            } catch (e) {
                debug_qdrant('Initial refresh_vector_statistics failed:', e);
                try { toastr.error(`Failed to refresh vector statistics: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) { }
            }
        }
    } catch (e) {
        console.error(`[${MODULE_NAME_FANCY}] Initialization post-load failed:`, e);
        try { toastr.error(`Initialization failed: ${e.message || String(e)}`, MODULE_NAME_FANCY); } catch (t) {}
    }
    
    log('Context Truncator loaded successfully');
});