<?php
/**
 * WEVIA Claude Code Patterns v1.0 — 31 mars 2026
 * 
 * Architectural patterns extracted from Claude Code source leak analysis:
 * 1. Token Budget Continuation — auto-resume on truncated outputs
 * 2. Three-Layer Context Compression — snip/compact/collapse
 * 3. Provider Effort Levels — intent complexity → provider tier mapping
 * 4. Deferred Tool Discovery — core vs specialized tool split (-85% tokens)
 * 5. Tool Alphabetical Sorting — prompt cache stability
 * 6. Memory Consolidation Framework — Dream-like session memory
 * 7. Enhanced Circuit Breaker — per-provider health tracking with decay
 * 8. Concurrency Safety Tiers — read-only vs write tool classification
 * 
 * Usage: require_once __DIR__ . '/wevia-claude-code-patterns.php';
 * All functions are prefixed with wcp_ (wevia-claude-patterns)
 */

define('WCP_VERSION', '1.0.0');
define('WCP_MAX_MEMORY_LINES', 200); // Dream consolidation cap (from Claude Code)

// ═══════════════════════════════════════════════════════════════
// 1. TOKEN BUDGET CONTINUATION
// When a provider truncates output mid-task, inject invisible 
// meta-message and retry. Up to 3 recovery attempts.
// ═══════════════════════════════════════════════════════════════

function wcp_detect_truncation($response, $finish_reason = null) {
    // Explicit truncation signal from API
    if ($finish_reason === 'length') return true;
    
    // Heuristic: response ends mid-sentence (no terminal punctuation)
    $trimmed = rtrim($response);
    if (empty($trimmed)) return false;
    
    $lastChar = mb_substr($trimmed, -1);
    $terminals = ['.', '!', '?', ':', ';', '```', '>', ')', ']', '}', '"', "'", "\n"];
    
    // If response is long enough and doesn't end with terminal punctuation
    if (mb_strlen($trimmed) > 200 && !in_array($lastChar, $terminals)) {
        // Additional check: ends mid-code-block?
        $openBlocks = substr_count($trimmed, '```');
        if ($openBlocks % 2 !== 0) return true; // Unclosed code block
        return true;
    }
    
    return false;
}

function wcp_continuation_message($partial_response) {
    // Invisible meta-message that instructs the model to resume
    // Pattern from Claude Code: "Resume directly — no apology, no recap"
    return [
        "role" => "user",
        "content" => "[SYSTEM: Your previous response was truncated at the token limit. Continue EXACTLY where you left off. Do NOT apologize, do NOT recap what you already said, do NOT restart. Resume mid-sentence if needed. Here is your last 200 chars for context: \"" . mb_substr($partial_response, -200) . "\"]"
    ];
}

function wcp_auto_continue($callProvider, $messages, $sys, $provider, $maxAttempts = 3) {
    $fullResponse = '';
    $attempts = 0;
    
    while ($attempts < $maxAttempts) {
        $result = $callProvider($messages, $sys, $provider);
        if (!$result || empty($result['response'])) break;
        
        $fullResponse .= $result['response'];
        $attempts++;
        
        // Check if truncated
        $finishReason = $result['finish_reason'] ?? null;
        if (!wcp_detect_truncation($result['response'], $finishReason)) {
            break; // Complete response
        }
        
        // Inject continuation message
        $messages[] = ["role" => "assistant", "content" => $result['response']];
        $messages[] = wcp_continuation_message($result['response']);
        
        error_log("WCP_CONTINUE: attempt=$attempts provider=$provider partial_len=" . mb_strlen($result['response']));
    }
    
    return [
        'response' => $fullResponse,
        'attempts' => $attempts,
        'continued' => $attempts > 1
    ];
}


// ═══════════════════════════════════════════════════════════════
// 2. THREE-LAYER CONTEXT COMPRESSION
// Layer 1: snipCompact — trim low-value segments
// Layer 2: autoCompact — summarize conversation history  
// Layer 3: contextCollapse — restructure for provider limits
// ═══════════════════════════════════════════════════════════════

function wcp_snip_compact($history, $maxTokenEstimate = 8000) {
    /**
     * Layer 1: Remove low-value exchanges from history
     * - Greetings and acknowledgments
     * - Repeated questions
     * - Error messages that were resolved
     */
    if (empty($history)) return $history;
    
    $snipped = [];
    $totalEstTokens = 0;
    
    // Process from newest to oldest (keep recent context)
    $reversed = array_reverse($history);
    
    foreach ($reversed as $msg) {
        $content = $msg['content'] ?? '';
        $tokenEst = (int)(mb_strlen($content) / 3.5); // rough token estimate
        
        // Skip low-value messages
        if (wcp_is_low_value($content, $msg['role'] ?? 'user')) {
            continue;
        }
        
        $totalEstTokens += $tokenEst;
        if ($totalEstTokens > $maxTokenEstimate) {
            // Summarize remaining old messages
            $remaining = array_slice($reversed, count($snipped));
            if (!empty($remaining)) {
                $summary = wcp_summarize_block($remaining);
                if ($summary) {
                    $snipped[] = ["role" => "system", "content" => "[Résumé conversation précédente: $summary]"];
                }
            }
            break;
        }
        
        $snipped[] = $msg;
    }
    
    return array_reverse($snipped);
}

function wcp_is_low_value($content, $role) {
    $l = mb_strtolower(trim($content));
    $len = mb_strlen($l);
    
    // Very short acknowledgments
    if ($len < 15 && preg_match('/^(ok|oui|non|merci|d.accord|parfait|super|cool|top|nice|yes|no|thanks|got it|compris|entendu|noté)$/i', $l)) {
        return true;
    }
    
    // Pure greetings without substance
    if ($len < 30 && preg_match('/^(bonjour|bonsoir|salut|hello|hi|hey|salam|coucou)\s*(claude|wevia|!|\.|\?)?$/i', $l)) {
        return true;
    }
    
    return false;
}

function wcp_summarize_block($messages) {
    /**
     * Generate a compact summary of a conversation block.
     * Uses extractive summarization (key phrases) not LLM calls.
     */
    $topics = [];
    foreach ($messages as $msg) {
        $content = $msg['content'] ?? '';
        // Extract key entities/topics via simple NLP
        if (preg_match_all('/(?:SAP|ERP|WEVIA|Arsenal|Ethica|API|server|docker|nginx|postgresql|kubernetes|python|php|react|audit|compliance|RGPD|cybersécurité|pharma|marketing|CRM|pipeline)/i', $content, $matches)) {
            $topics = array_merge($topics, array_map('strtolower', $matches[0]));
        }
    }
    
    $topicCounts = array_count_values($topics);
    arsort($topicCounts);
    $topTopics = array_slice(array_keys($topicCounts), 0, 5);
    
    if (empty($topTopics)) return null;
    
    $msgCount = count($messages);
    return "Discussion de $msgCount échanges couvrant: " . implode(', ', $topTopics);
}

function wcp_auto_compact($history, $targetTokens = 4000) {
    /**
     * Layer 2: Aggressive summarization when context is critical.
     * Keeps last 4 exchanges intact, summarizes everything else.
     */
    if (count($history) <= 8) return $history; // 4 exchanges = 8 messages
    
    $recent = array_slice($history, -8);
    $old = array_slice($history, 0, -8);
    
    $summary = wcp_summarize_block($old);
    $compacted = [];
    
    if ($summary) {
        $compacted[] = ["role" => "system", "content" => "[Contexte précédent: $summary]"];
    }
    
    return array_merge($compacted, $recent);
}

function wcp_context_collapse($sys, $kbContext, $history, $providerMaxTokens = 32000) {
    /**
     * Layer 3: Restructure entire context for provider-specific limits.
     * Different providers have different context windows:
     * - Cerebras qwen-3-235b: 8K-32K
     * - Groq llama-3.3-70b: 128K  
     * - Ollama local qwen3:4b: 8K
     * - Gemini 2.0 flash: 1M
     * 
     * Collapse strategy: sys + kb + history must fit in providerMaxTokens
     */
    $sysTokens = (int)(mb_strlen($sys) / 3.5);
    $kbTokens = (int)(mb_strlen($kbContext) / 3.5);
    $histTokens = 0;
    foreach ($history as $h) {
        $histTokens += (int)(mb_strlen($h['content'] ?? '') / 3.5);
    }
    
    $totalTokens = $sysTokens + $kbTokens + $histTokens;
    
    if ($totalTokens <= $providerMaxTokens * 0.85) {
        return ['sys' => $sys, 'kb' => $kbContext, 'history' => $history]; // Fits fine
    }
    
    error_log("WCP_COLLAPSE: total={$totalTokens} limit={$providerMaxTokens} — compressing");
    
    // Step 1: Trim KB context (least important)
    if ($kbTokens > $providerMaxTokens * 0.2) {
        $maxKbChars = (int)($providerMaxTokens * 0.2 * 3.5);
        $kbContext = mb_substr($kbContext, 0, $maxKbChars) . "\n[...KB tronquée pour limites contexte...]";
    }
    
    // Step 2: Compact history
    $history = wcp_snip_compact($history, (int)($providerMaxTokens * 0.4));
    
    // Step 3: If still too large, aggressive compact
    $newTotal = (int)(mb_strlen($sys) / 3.5) + (int)(mb_strlen($kbContext) / 3.5);
    foreach ($history as $h) $newTotal += (int)(mb_strlen($h['content'] ?? '') / 3.5);
    
    if ($newTotal > $providerMaxTokens * 0.85) {
        $history = wcp_auto_compact($history, (int)($providerMaxTokens * 0.3));
    }
    
    // Step 4: UNIVERSAL safe cap — brain's fallback chain may reach smaller providers
    // Nuclear trim if sys prompt > 6K chars (safe for ALL providers including Cerebras 8K)
    if (mb_strlen($sys) > 6000) {
        $sys = mb_substr($sys, 0, 4000) . "\n[...expertises condensées pour optimisation contexte...]\n" . mb_substr($sys, -2000);
        error_log("WCP_COLLAPSE: UNIVERSAL cap sys=" . mb_strlen($sys) . " (was >" . 6000 . ")");
    }
    if ($newTotal > $providerMaxTokens * 0.9) {
        // Keep core identity + security, trim expertise details
        if (preg_match('/EXPERTISE [A-Z]+:/s', $sys)) {
            // Remove all EXPERTISE blocks but keep CONTACT and SECURITE INTERNE
            $sys = preg_replace('/EXPERTISE (?:SECURITE|PHARMA|ERP|PDF|SCHEMA|API|FRONTEND|DEVOPS|RGPD|IA ETHICS)[^E]+((?=EXPERTISE)|(?=CONTACT)|(?=SECURITE INTERNE)|(?=QUALITE))/s', "[Expertise condensée]\n", $sys);
            error_log("WCP_COLLAPSE: Trimmed EXPERTISE blocks");
        }
    }
    
    return ['sys' => $sys, 'kb' => $kbContext, 'history' => $history];
}


// ═══════════════════════════════════════════════════════════════
// 3. PROVIDER EFFORT LEVELS
// Map intent complexity to provider tiers.
// Pattern from Claude Code: low/medium/high effort → model selection
// ═══════════════════════════════════════════════════════════════

/**
 * Provider capability tiers for WEVIA's multi-provider fallback
 */
define('WCP_TIER_FAST', 'fast');       // Simple/greetings: cheapest, fastest provider
define('WCP_TIER_BALANCED', 'balanced'); // General: good balance of speed + quality
define('WCP_TIER_DEEP', 'deep');       // Complex reasoning: best available model
define('WCP_TIER_SPECIALIST', 'specialist'); // Domain-specific: vision, code, etc.

function wcp_provider_tiers() {
    return [
        WCP_TIER_FAST => ['cerebras', 'groq', 'sambanova', 'ollama_s95'],
        WCP_TIER_BALANCED => ['groq', 'alibaba', 'sambanova', 'mistral', 'deepseek'], // cerebras=8K too small for full sys
        WCP_TIER_DEEP => ['groq_deep', 'deepseek', 'gemini', 'cohere', 'alibaba'], // no cerebras=8K
        WCP_TIER_SPECIALIST => [
            'vision' => ['gemini', 'groq_vision'],
            'code' => ['cerebras', 'deepseek'],
            'rag' => ['cohere', 'groq_deep'],
            'multilingual' => ['mistral', 'alibaba', 'gemini'],
        ],
    ];
}

function wcp_classify_effort($intent, $msg, $mode = 'balanced') {
    /**
     * Determine effort level based on intent + message complexity.
     * Returns: [tier, priority_providers[], context_budget]
     */
    $msgLen = mb_strlen($msg);
    $tiers = wcp_provider_tiers();
    
    // Fast tier: greetings, short messages, acknowledgments
    if ($intent === 'greeting' || $mode === 'fast' || $msgLen < 20) {
        return [
            'tier' => WCP_TIER_FAST,
            'providers' => $tiers[WCP_TIER_FAST],
            'context_budget' => 4000,
            'max_tokens' => 512,
        ];
    }
    
    // Specialist tier: domain-specific intents
    if ($intent === 'image') {
        return ['tier' => WCP_TIER_SPECIALIST, 'providers' => $tiers[WCP_TIER_SPECIALIST]['vision'], 'context_budget' => 8000, 'max_tokens' => 2048];
    }
    if ($intent === 'code' || $intent === 'schema') {
        return ['tier' => WCP_TIER_SPECIALIST, 'providers' => $tiers[WCP_TIER_SPECIALIST]['code'], 'context_budget' => 16000, 'max_tokens' => 4096];
    }
    
    // Deep tier: complex reasoning, analysis, compliance, medical
    if (in_array($intent, ['analysis', 'compliance', 'medical', 'consulting']) || $mode === 'verified') {
        return [
            'tier' => WCP_TIER_DEEP,
            'providers' => $tiers[WCP_TIER_DEEP],
            'context_budget' => 24000,
            'max_tokens' => 4096,
        ];
    }
    
    // Long messages suggest complex queries
    if ($msgLen > 300) {
        return [
            'tier' => WCP_TIER_DEEP,
            'providers' => $tiers[WCP_TIER_DEEP],
            'context_budget' => 16000,
            'max_tokens' => 4096,
        ];
    }
    
    // Balanced tier: everything else
    return [
        'tier' => WCP_TIER_BALANCED,
        'providers' => $tiers[WCP_TIER_BALANCED],
        'context_budget' => 12000,
        'max_tokens' => 2048,
    ];
}

function wcp_smart_route_v3($msg, $mode, $intent, $cbState = []) {
    /**
     * Enhanced smartRoute using effort levels + circuit breaker state.
     * Falls through providers in tier order, skipping broken ones.
     */
    $effort = wcp_classify_effort($intent, $msg, $mode);
    $providers = $effort['providers'];
    
    // Filter out circuit-broken providers
    foreach ($providers as $i => $p) {
        if (isset($cbState[$p]) && $cbState[$p]['blocked']) {
            unset($providers[$i]);
        }
    }
    $providers = array_values($providers);
    
    if (empty($providers)) {
        // All providers in tier are broken — fallback to ollama
        error_log("WCP_ROUTE: all tier={$effort['tier']} providers broken, fallback ollama");
        return ['provider' => 'ollama_s95', 'effort' => $effort];
    }
    
    error_log("WCP_ROUTE: tier={$effort['tier']} provider={$providers[0]} budget={$effort['context_budget']}");
    return ['provider' => $providers[0], 'effort' => $effort];
}


// ═══════════════════════════════════════════════════════════════
// 4. DEFERRED TOOL DISCOVERY
// Only surface core tools in the base prompt.
// Load specialized tools on-demand when the model requests them.
// This reduces prompt token usage by ~85%.
// ═══════════════════════════════════════════════════════════════

function wcp_tool_registry() {
    /**
     * Complete tool catalog with metadata.
     * core=true means always present in prompt.
     * core=false means loaded via deferred discovery.
     */
    return [
        // ═══ CORE TOOLS (always in prompt) ═══
        'web_search' => ['core' => true, 'safety' => 'read', 'desc' => 'Recherche web en temps réel'],
        'kb_search' => ['core' => true, 'safety' => 'read', 'desc' => 'Recherche base de connaissances WEVIA'],
        'mermaid' => ['core' => true, 'safety' => 'read', 'desc' => 'Génération de schémas Mermaid'],
        'pdf_generate' => ['core' => true, 'safety' => 'write', 'desc' => 'Génération de documents PDF'],
        'code_execute' => ['core' => true, 'safety' => 'write', 'desc' => 'Exécution de code Python/PHP'],
        'image_generate' => ['core' => true, 'safety' => 'write', 'desc' => 'Génération d\'images IA'],
        'svg_logo' => ['core' => true, 'safety' => 'write', 'desc' => 'Génération de logos SVG'],
        'tool_search' => ['core' => true, 'safety' => 'read', 'desc' => 'Découvrir des outils spécialisés disponibles'],
        
        // ═══ SPECIALIZED TOOLS (loaded on demand) ═══
        'nuclei_scan' => ['core' => false, 'safety' => 'write', 'category' => 'security', 'desc' => 'Scan de vulnérabilités Nuclei'],
        'kilo_cli' => ['core' => false, 'safety' => 'write', 'category' => 'devops', 'desc' => 'Kilo CLI pour gestion serveurs'],
        'toolFK' => ['core' => false, 'safety' => 'read', 'category' => 'data', 'desc' => '25 outils data: JSON, CSV, XML, regex, hash, etc.'],
        'ethica_hcp' => ['core' => false, 'safety' => 'read', 'category' => 'pharma', 'desc' => 'Recherche HCP base Ethica'],
        'arsenal_query' => ['core' => false, 'safety' => 'write', 'category' => 'marketing', 'desc' => 'Requêtes Arsenal WEVADS'],
        'domain_check' => ['core' => false, 'safety' => 'read', 'category' => 'marketing', 'desc' => 'Vérification domaine email (DKIM/SPF/DMARC)'],
        'cron_manager' => ['core' => false, 'safety' => 'write', 'category' => 'devops', 'desc' => 'Gestion des crons serveur'],
        'db_query' => ['core' => false, 'safety' => 'read', 'category' => 'data', 'desc' => 'Requêtes PostgreSQL en lecture'],
        'git_status' => ['core' => false, 'safety' => 'read', 'category' => 'devops', 'desc' => 'Statut des repos Git'],
        'docker_status' => ['core' => false, 'safety' => 'read', 'category' => 'devops', 'desc' => 'Statut des conteneurs Docker'],
        'uptime_check' => ['core' => false, 'safety' => 'read', 'category' => 'monitoring', 'desc' => 'Statut Uptime Kuma'],
        'plausible_stats' => ['core' => false, 'safety' => 'read', 'category' => 'analytics', 'desc' => 'Statistiques Plausible Analytics'],
        'searxng' => ['core' => false, 'safety' => 'read', 'category' => 'search', 'desc' => 'Recherche SearXNG souveraine'],
        'n8n_workflow' => ['core' => false, 'safety' => 'write', 'category' => 'automation', 'desc' => 'Déclenchement workflows n8n'],
        'warmup_control' => ['core' => false, 'safety' => 'write', 'category' => 'marketing', 'desc' => 'Contrôle warmup emails'],
        'contact_import' => ['core' => false, 'safety' => 'write', 'category' => 'marketing', 'desc' => 'Import contacts CSV'],
        'ai_template' => ['core' => false, 'safety' => 'write', 'category' => 'marketing', 'desc' => 'Génération templates email IA'],
        'rlhf_feedback' => ['core' => false, 'safety' => 'write', 'category' => 'system', 'desc' => 'Feedback RLHF utilisateur'],
    ];
}

function wcp_get_core_tools() {
    /**
     * Return only core tools for the base prompt.
     * Sorted alphabetically for prompt cache stability.
     */
    $registry = wcp_tool_registry();
    $core = array_filter($registry, fn($t) => $t['core'] === true);
    ksort($core); // Alphabetical sort for cache stability
    return $core;
}

function wcp_discover_tools($query) {
    /**
     * Deferred tool discovery: search specialized tools by keyword.
     * Called when the model uses the tool_search meta-tool.
     */
    $registry = wcp_tool_registry();
    $specialized = array_filter($registry, fn($t) => $t['core'] === false);
    
    $query = mb_strtolower($query);
    $results = [];
    
    foreach ($specialized as $name => $tool) {
        $searchable = mb_strtolower($name . ' ' . $tool['desc'] . ' ' . ($tool['category'] ?? ''));
        if (mb_strpos($searchable, $query) !== false) {
            $results[$name] = $tool;
        }
    }
    
    // Also match by category
    foreach ($specialized as $name => $tool) {
        if (isset($tool['category']) && mb_strpos(mb_strtolower($tool['category']), $query) !== false) {
            $results[$name] = $tool;
        }
    }
    
    ksort($results); // Alphabetical for cache stability
    return $results;
}

function wcp_tool_discovery_prompt() {
    /**
     * Generate the tool_search instruction for the system prompt.
     * This replaces listing all 25+ tools.
     */
    $core = wcp_get_core_tools();
    $specialized = array_filter(wcp_tool_registry(), fn($t) => $t['core'] === false);
    $categories = array_unique(array_filter(array_map(fn($t) => $t['category'] ?? null, $specialized)));
    sort($categories);
    
    $prompt = "OUTILS DISPONIBLES:\n";
    foreach ($core as $name => $tool) {
        $prompt .= "- $name: {$tool['desc']}\n";
    }
    $prompt .= "\nOUTILS SPÉCIALISÉS (utilise tool_search pour les découvrir):\n";
    $prompt .= "Catégories: " . implode(', ', $categories) . "\n";
    $prompt .= "Pour accéder aux outils spécialisés, utilise: tool_search(\"catégorie ou mot-clé\")\n";
    $prompt .= "Exemple: tool_search(\"security\") → nuclei_scan, etc.\n";
    
    return $prompt;
}


// ═══════════════════════════════════════════════════════════════
// 5. ENHANCED CIRCUIT BREAKER
// Per-provider health tracking with exponential decay.
// Pattern: track failures, auto-recover after cooldown.
// ═══════════════════════════════════════════════════════════════

function wcp_cb_state_file() {
    return '/tmp/wcp_circuit_breaker.json';
}

function wcp_cb_load() {
    $file = wcp_cb_state_file();
    if (!file_exists($file)) return [];
    $data = @json_decode(file_get_contents($file), true);
    return is_array($data) ? $data : [];
}

function wcp_cb_save($state) {
    file_put_contents(wcp_cb_state_file(), json_encode($state));
}

function wcp_cb_record_failure($provider) {
    $state = wcp_cb_load();
    if (!isset($state[$provider])) {
        $state[$provider] = ['failures' => 0, 'last_failure' => 0, 'blocked' => false, 'blocked_until' => 0];
    }
    
    $state[$provider]['failures']++;
    $state[$provider]['last_failure'] = time();
    
    // Block after 3 consecutive failures
    if ($state[$provider]['failures'] >= 3) {
        // Exponential backoff: 30s, 60s, 120s, 240s, max 600s
        $cooldown = min(600, 30 * pow(2, $state[$provider]['failures'] - 3));
        $state[$provider]['blocked'] = true;
        $state[$provider]['blocked_until'] = time() + $cooldown;
        error_log("WCP_CB: BLOCKED provider=$provider failures={$state[$provider]['failures']} cooldown={$cooldown}s");
    }
    
    wcp_cb_save($state);
    return $state;
}

function wcp_cb_record_success($provider) {
    $state = wcp_cb_load();
    if (isset($state[$provider])) {
        // Decay failures on success (don't reset to 0 immediately)
        $state[$provider]['failures'] = max(0, $state[$provider]['failures'] - 1);
        $state[$provider]['blocked'] = false;
        $state[$provider]['blocked_until'] = 0;
    }
    wcp_cb_save($state);
    return $state;
}

function wcp_cb_is_available($provider) {
    $state = wcp_cb_load();
    if (!isset($state[$provider])) return true;
    
    $p = $state[$provider];
    if (!$p['blocked']) return true;
    
    // Auto-recover after cooldown
    if (time() > $p['blocked_until']) {
        $state[$provider]['blocked'] = false;
        wcp_cb_save($state);
        error_log("WCP_CB: AUTO_RECOVER provider=$provider");
        return true;
    }
    
    return false;
}

function wcp_cb_available_providers($providerList) {
    return array_filter($providerList, fn($p) => wcp_cb_is_available($p));
}


// ═══════════════════════════════════════════════════════════════
// 6. CONCURRENCY SAFETY TIERS
// Classification of tools as read-only (safe for parallel) 
// vs write (must be serial). From Claude Code pattern.
// ═══════════════════════════════════════════════════════════════

function wcp_tool_safety($toolName) {
    $registry = wcp_tool_registry();
    return $registry[$toolName]['safety'] ?? 'write'; // Default to write (safe)
}

function wcp_can_parallel($tools) {
    /**
     * Check if a set of tools can all run in parallel.
     * Only if ALL tools are read-only.
     */
    foreach ($tools as $tool) {
        if (wcp_tool_safety($tool) !== 'read') return false;
    }
    return true;
}


// ═══════════════════════════════════════════════════════════════
// 7. MEMORY CONSOLIDATION (DREAM SYSTEM)
// Background process that consolidates session memories.
// Phases: Orient → Gather → Consolidate → Prune
// Designed to run as a cron job.
// ═══════════════════════════════════════════════════════════════

function wcp_dream_consolidate($pdo, $sessionId = null) {
    /**
     * Dream consolidation for WEVIA session memory.
     * 
     * Phase 1 - Orient: Load existing memory file
     * Phase 2 - Gather: Extract key facts from recent sessions
     * Phase 3 - Consolidate: Merge, deduplicate, resolve contradictions
     * Phase 4 - Prune: Keep under WCP_MAX_MEMORY_LINES (200)
     * 
     * Storage: admin.wevia_memory table
     */
    
    // Ensure memory table exists
    try {
        $pdo->exec("CREATE TABLE IF NOT EXISTS admin.wevia_memory (
            id SERIAL PRIMARY KEY,
            session_id VARCHAR(100),
            category VARCHAR(50) DEFAULT 'general',
            fact TEXT NOT NULL,
            confidence FLOAT DEFAULT 1.0,
            source VARCHAR(100),
            created_at TIMESTAMP DEFAULT NOW(),
            updated_at TIMESTAMP DEFAULT NOW(),
            contradicted_by INT REFERENCES admin.wevia_memory(id),
            active BOOLEAN DEFAULT true
        )");
        $pdo->exec("CREATE INDEX IF NOT EXISTS idx_wevia_memory_active ON admin.wevia_memory(active) WHERE active = true");
        $pdo->exec("CREATE INDEX IF NOT EXISTS idx_wevia_memory_session ON admin.wevia_memory(session_id)");
    } catch(\Exception $e) {
        error_log("WCP_DREAM: table creation error: " . $e->getMessage());
        return false;
    }
    
    // Phase 1: Orient — Load current memories
    $currentMemories = [];
    try {
        $st = $pdo->query("SELECT id, category, fact, confidence, created_at FROM admin.wevia_memory WHERE active = true ORDER BY confidence DESC, updated_at DESC LIMIT 200");
        $currentMemories = $st->fetchAll(\PDO::FETCH_ASSOC);
    } catch(\Exception $e) {
        error_log("WCP_DREAM: orient error: " . $e->getMessage());
    }
    
    // Phase 2: Gather — Extract facts from recent RLHF/conversations
    $recentFacts = [];
    try {
        // Get recent conversations that haven't been consolidated
        $st = $pdo->query("SELECT question, answer, provider, created_at FROM admin.rlhf_feedback 
                          WHERE created_at > NOW() - INTERVAL '7 days' 
                          ORDER BY created_at DESC LIMIT 100");
        $conversations = $st->fetchAll(\PDO::FETCH_ASSOC);
        
        foreach ($conversations as $conv) {
            $extracted = wcp_extract_facts($conv['question'], $conv['answer']);
            foreach ($extracted as $fact) {
                $recentFacts[] = array_merge($fact, ['source' => 'rlhf_' . substr(md5($conv['created_at']), 0, 8)]);
            }
        }
    } catch(\Exception $e) {
        error_log("WCP_DREAM: gather error: " . $e->getMessage());
    }
    
    // Phase 3: Consolidate — Merge with existing, resolve contradictions
    $consolidated = wcp_merge_memories($currentMemories, $recentFacts, $pdo);
    
    // Phase 4: Prune — Keep under 200 lines
    $pruned = wcp_prune_memories($consolidated, WCP_MAX_MEMORY_LINES);
    
    error_log("WCP_DREAM: consolidated " . count($recentFacts) . " new facts, total active=" . count($pruned));
    
    return ['new_facts' => count($recentFacts), 'total' => count($pruned), 'pruned' => count($consolidated) - count($pruned)];
}

function wcp_extract_facts($question, $answer) {
    /**
     * Extract factual claims from a Q&A exchange.
     * Simple extractive approach — no LLM needed.
     */
    $facts = [];
    $combined = $question . ' ' . $answer;
    
    // Extract technology mentions
    if (preg_match_all('/(utilise|recommande|implementé|déployé|configuré)\s+(\w+(?:\s+\w+)?)/iu', $combined, $m)) {
        foreach ($m[0] as $match) {
            $facts[] = ['category' => 'technology', 'fact' => trim($match), 'confidence' => 0.7];
        }
    }
    
    // Extract decisions
    if (preg_match_all('/(choisi|décidé|opté pour|validé|confirmé)\s+(.+?)[\.\,\;]/iu', $combined, $m)) {
        foreach ($m[0] as $match) {
            $facts[] = ['category' => 'decision', 'fact' => trim($match), 'confidence' => 0.9];
        }
    }
    
    // Extract problems/solutions
    if (preg_match_all('/(problème|erreur|bug|fix|solution|résolu)\s*:?\s*(.{20,100})/iu', $combined, $m)) {
        foreach ($m[0] as $match) {
            $facts[] = ['category' => 'troubleshoot', 'fact' => trim($match), 'confidence' => 0.8];
        }
    }
    
    return $facts;
}

function wcp_merge_memories($existing, $newFacts, $pdo) {
    /**
     * Merge new facts with existing memories.
     * Detect duplicates via fuzzy matching.
     * Resolve contradictions (newer wins, mark old as contradicted).
     */
    $merged = $existing;
    
    foreach ($newFacts as $fact) {
        $isDuplicate = false;
        
        foreach ($existing as $mem) {
            // Simple fuzzy match: >70% shared words
            $simil = wcp_text_similarity($fact['fact'], $mem['fact']);
            if ($simil > 0.7) {
                $isDuplicate = true;
                // Update confidence if new is higher
                if ($fact['confidence'] > $mem['confidence']) {
                    try {
                        $pdo->prepare("UPDATE admin.wevia_memory SET confidence = ?, updated_at = NOW() WHERE id = ?")
                            ->execute([$fact['confidence'], $mem['id']]);
                    } catch(\Exception $e) {}
                }
                break;
            }
        }
        
        if (!$isDuplicate) {
            // Insert new fact
            try {
                $st = $pdo->prepare("INSERT INTO admin.wevia_memory (category, fact, confidence, source) VALUES (?, ?, ?, ?)");
                $st->execute([$fact['category'], $fact['fact'], $fact['confidence'], $fact['source'] ?? 'dream']);
                $merged[] = $fact;
            } catch(\Exception $e) {
                error_log("WCP_DREAM: insert error: " . $e->getMessage());
            }
        }
    }
    
    return $merged;
}

function wcp_prune_memories($memories, $maxLines) {
    /**
     * Keep only top N memories by confidence * recency.
     * Deactivate old/low-confidence ones.
     */
    // Already within limits
    if (count($memories) <= $maxLines) return $memories;
    
    // Sort by confidence DESC, created_at DESC
    usort($memories, function($a, $b) {
        $confDiff = ($b['confidence'] ?? 0.5) - ($a['confidence'] ?? 0.5);
        if (abs($confDiff) > 0.01) return $confDiff > 0 ? 1 : -1;
        return strcmp($b['created_at'] ?? '', $a['created_at'] ?? '');
    });
    
    return array_slice($memories, 0, $maxLines);
}

function wcp_text_similarity($a, $b) {
    $wordsA = array_unique(preg_split('/\s+/', mb_strtolower($a)));
    $wordsB = array_unique(preg_split('/\s+/', mb_strtolower($b)));
    
    if (empty($wordsA) || empty($wordsB)) return 0;
    
    $intersection = count(array_intersect($wordsA, $wordsB));
    $union = count(array_unique(array_merge($wordsA, $wordsB)));
    
    return $union > 0 ? $intersection / $union : 0;
}

function wcp_get_session_memory($pdo, $limit = 20) {
    /**
     * Load active memories for injection into system prompt.
     * Returns formatted string for prompt enrichment.
     */
    try {
        $st = $pdo->query("SELECT category, fact FROM admin.wevia_memory 
                          WHERE active = true 
                          ORDER BY confidence DESC, updated_at DESC 
                          LIMIT $limit");
        $memories = $st->fetchAll(\PDO::FETCH_ASSOC);
        
        if (empty($memories)) return '';
        
        $grouped = [];
        foreach ($memories as $m) {
            $grouped[$m['category']][] = $m['fact'];
        }
        
        $prompt = "\nMÉMOIRE CONSOLIDÉE:\n";
        foreach ($grouped as $cat => $facts) {
            $prompt .= strtoupper($cat) . ": " . implode('; ', array_slice($facts, 0, 5)) . "\n";
        }
        
        return $prompt;
    } catch(\Exception $e) {
        return '';
    }
}


// ═══════════════════════════════════════════════════════════════
// 8. PROVIDER CONTEXT WINDOWS
// Map each provider to its actual context window limit.
// Used by context_collapse to optimize per-provider.
// ═══════════════════════════════════════════════════════════════

function wcp_provider_context_limits() {
    return [
        'cerebras' => 8192,
        'groq' => 131072,
        'groq_deep' => 131072,
        'groq_vision' => 131072,
        'ollama_s95' => 8192,
        'ollama_local' => 8192,
        'mistral' => 32768,
        'deepseek' => 65536,
        'alibaba' => 32768,
        'sambanova' => 65536,
        'gemini' => 1048576,
        'cohere' => 131072,
    ];
}

function wcp_get_context_limit($provider) {
    $limits = wcp_provider_context_limits();
    return $limits[$provider] ?? 8192; // Conservative default
}


// ═══════════════════════════════════════════════════════════════
// 9. CRASH-SAFE PERSISTENCE
// Write conversation state before API calls.
// Pattern from Claude Code: JSONL format, session resumable.
// ═══════════════════════════════════════════════════════════════

function wcp_persist_turn($sessionId, $role, $content, $provider = '', $metadata = []) {
    $logDir = '/var/www/weval/wevia-ia/session-logs';
    if (!is_dir($logDir)) @mkdir($logDir, 0755, true);
    
    $entry = json_encode([
        'ts' => date('c'),
        'session' => $sessionId,
        'role' => $role,
        'content' => mb_substr($content, 0, 5000), // Cap for storage
        'provider' => $provider,
        'meta' => $metadata,
    ], JSON_UNESCAPED_UNICODE) . "\n";
    
    @file_put_contents("$logDir/$sessionId.jsonl", $entry, FILE_APPEND | LOCK_EX);
}

function wcp_load_session($sessionId) {
    $file = "/var/www/weval/wevia-ia/session-logs/$sessionId.jsonl";
    if (!file_exists($file)) return [];
    
    $lines = file($file, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
    $turns = [];
    foreach ($lines as $line) {
        $turn = @json_decode($line, true);
        if ($turn) $turns[] = $turn;
    }
    return $turns;
}


// ═══════════════════════════════════════════════════════════════
// INTEGRATION HELPER
// One-call function to wire all patterns into the existing brain.
// ═══════════════════════════════════════════════════════════════

function wcp_enhance_request($msg, $mode, $intent, $history, $sys, $kbContext, $provider, $pdo = null) {
    /**
     * Main integration point. Call this before sending to a provider.
     * Returns enhanced parameters ready for API call.
     */
    
    // 1. Classify effort and get optimal provider
    $route = wcp_smart_route_v3($msg, $mode, $intent, wcp_cb_load());
    $selectedProvider = $route['provider'];
    $effort = $route['effort'];
    
    // 2. Get provider context limit
    $contextLimit = wcp_get_context_limit($selectedProvider);
    
    // 3. Apply three-layer context compression
    $compressed = wcp_context_collapse($sys, $kbContext, $history, $contextLimit);
    
    // 4. Inject session memory if available
    if ($pdo) {
        $memory = wcp_get_session_memory($pdo, 10);
        if ($memory) {
            $compressed['sys'] .= $memory;
        }
    }
    
    // 5. Add tool discovery prompt
    $compressed['sys'] .= "\n" . wcp_tool_discovery_prompt();
    
    // 6. Persist turn for crash safety
    $sessionId = session_id() ?: md5(microtime());
    wcp_persist_turn($sessionId, 'user', $msg, $selectedProvider);
    
    return [
        'provider' => $selectedProvider,
        'effort' => $effort,
        'sys' => $compressed['sys'],
        'kb' => $compressed['kb'],
        'history' => $compressed['history'],
        'context_limit' => $contextLimit,
        'max_tokens' => $effort['max_tokens'],
        'session_id' => $sessionId,
    ];
}

// Log module load
error_log("WCP: wevia-claude-code-patterns v" . WCP_VERSION . " loaded (" . count(wcp_tool_registry()) . " tools registered)");