GemmaCLI.ps1

[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
$OutputEncoding = [System.Text.Encoding]::UTF8

# =========================================================================================
# PRE-FLIGHT & AUTO-UNBLOCKER (Fix for GitHub / Internet Downloads)
# =========================================================================================
$script:scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
try {
    # 1. Elevate the current session's policy so we can actually load our libraries.
    # This ONLY affects this specific window/process, not your global system settings.
    Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process -Force -ErrorAction SilentlyContinue

    # 2. Recursively unblock all project files (Removes "Mark of the Web")
    Get-ChildItem -Path $script:scriptDir -Recurse -Include *.ps1,*.js,*.json -ErrorAction SilentlyContinue | Unblock-File -ErrorAction SilentlyContinue
} catch {
    Write-Host "`n [!] Security Warning: Windows is blocking this script's libraries." -ForegroundColor Yellow
    Write-Host " [!] Please run this command in a NEW PowerShell window to fix permanently:" -ForegroundColor Gray
    Write-Host "     Unblock-File -Path '$PSCommandPath'`n" -ForegroundColor Cyan
}

# Disable Expect100Continue handshake to prevent 417 errors and reduce latency
[System.Net.ServicePointManager]::Expect100Continue = $false

# Ensure UTF-8 output for emoji and Unicode rendering

# ====================== UNICODE CHARS ======================
$TL = [char]0x256D; $TR = [char]0x256E; $BL = [char]0x2570; $BR = [char]0x256F
$H = [char]0x2500;  $V = [char]0x2502;  $ARR = [char]0x2192; $CHK = [char]0x2713
$CRS = [char]0x2717; $DOT = [char]0x25CF; $BUL = [char]0x2022; $BLK = [char]0x2588
$LBK = [char]0x2591; $WRN = [char]0x26A0

# =========================================================================================
# SCRIPT INITIALIZATION
# =========================================================================================

# 1. Define Script Directory
$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition

# ====================== LOAD SETTINGS ======================
$settingsPath = Join-Path $scriptDir "config/settings.json"
$script:Settings = @{}
if (Test-Path $settingsPath) {
    try {
        $rawSettings = Get-Content $settingsPath | ConvertFrom-Json
        if ($rawSettings) {
            foreach ($prop in $rawSettings.PSObject.Properties) {
                $script:Settings[$prop.Name] = $prop.Value
            }
            # Apply hidden network settings
            if ($null -ne $script:Settings.disable_expect_100) {
                [System.Net.ServicePointManager]::Expect100Continue = (-not $script:Settings.disable_expect_100)
            }
        }
    } catch { }
}

# ====================== CORE REGISTRY & CONSTANTS ======================
# Dynamically load from settings, or fallback to safety if missing
$script:MODEL_REGISTRY = if ($script:Settings.model_registry) { 
    $script:Settings.model_registry 
} else {
    [ordered]@{
        "gemma-ultra" = @{ id = "gemma-3-27b-it"; label = "Gemma Ultra (27B)"; desc = "Highest reasoning & logic" }
    }
}

# Default to Ultra unless specified in settings
$script:MODEL_HANDLE = if ($script:Settings.current_model_handle) { $script:Settings.current_model_handle } else { "gemma-ultra" }
# Resolve handle to ID for API calls
$script:MODEL = $script:MODEL_REGISTRY.$($script:MODEL_HANDLE).id

$script:BASE_URI_BASE = "https://generativelanguage.googleapis.com/v1beta/models"

# Tool limits mapped to model IDs (for legacy compatibility) or Handles
$script:TOOL_LIMITS = @{
    "gemma-4-31b-it" = 12
    "gemma-4-26b-a4b-it" = 12
    "gemma-3-27b-it" = 12
    "gemma-3-12b-it" = 8
    "gemma-3-4b-it"  = 2
    "gemma-3n-e4b-it" = 2
    "gemma-3n-e2b-it" = 2
    "gemma-3-1b-it"  = 0
}

# 2. Source All Library Modules
. (Join-Path $scriptDir "lib/ToolLoader.ps1")
. (Join-Path $scriptDir "lib/Api.ps1")
. (Join-Path $scriptDir "lib/UI.ps1")
. (Join-Path $scriptDir "lib/History.ps1")

# ====================== DEBUG =======================
$script:debugMode = $false


# 4. Load API Key (Requires UI functions for Draw-Box)
# ====================== SECURE API KEY STORAGE ======================
$script:configDir  = Join-Path $env:APPDATA "GemmaCLI"

function Initialize-TTS {
    if (-not $global:GemmaTTS) {
        try {
            Add-Type -AssemblyName System.Speech
            $global:GemmaTTS = New-Object System.Speech.Synthesis.SpeechSynthesizer
            # Default to a female voice if available
            $global:GemmaTTS.SelectVoiceByHints([System.Speech.Synthesis.VoiceGender]::Female)
        } catch {
            Write-Host "  [!] Could not initialize Windows TTS." -ForegroundColor Red
            return $false
        }
    }
    return $true
}

function Format-TextForSpeech {
    param([string]$text)
    if ([string]::IsNullOrWhiteSpace($text)) { return "" }
    
    # Strip thoughts, channels, and code blocks
    $clean = $text -replace '(?s)<thought>.*?</thought>', ''
    $clean = $clean -replace '(?s)<\|channel>thought.*?<channel\|>', ''
    $clean = $clean -replace '(?s)<code_block>.*?</code_block>', ' [Code block omitted] '
    $clean = $clean -replace '(?s)```.*?```', ' [Code block omitted] '
    
    # Strip markdown markers
    $clean = $clean -replace '\*\*', ''
    $clean = $clean -replace '\*', ''
    
    return $clean.Trim()
}

function Save-ApiKey {
    param([string]$apiKey)
    Save-StoredKey -apiKey $apiKey -keyName "gemmacli"
    Draw-Box @("$CHK  API key saved securely (Windows user-only encryption)") -Color Green
}

# ====================== LOAD API KEY ======================
$API_KEY = $env:GEMMA_API_KEY
if (-not $API_KEY) { $API_KEY = Get-StoredKey -keyName "gemmacli" }
if (-not $API_KEY) {
    Write-Host "`n=== First-time setup (Gemma API) ===" -ForegroundColor Cyan
    Write-Host "Get your free Gemma API key here:" -ForegroundColor Yellow
    Write-Host "https://aistudio.google.com/app/apikey`n" -ForegroundColor Gray
    do {
        $secureInput = Read-Host "Enter your Gemma API key" -AsSecureString
        $plainKey    = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureInput))
        
        $confirmInput = Read-Host "Confirm key (paste again)" -AsSecureString
        $confirm      = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($confirmInput))

        if ($plainKey -ne $confirm) { Write-Host "$CRS  Keys do not match. Try again." -ForegroundColor Red }
        elseif ([string]::IsNullOrWhiteSpace($plainKey)) { Write-Host "$CRS  API key cannot be empty." -ForegroundColor Red }
    } while ($plainKey -ne $confirm -or [string]::IsNullOrWhiteSpace($plainKey))
    Save-ApiKey $plainKey
    $API_KEY = $plainKey
} else {
    Write-Host "$CHK  Gemma API key loaded successfully" -ForegroundColor DarkGray
}
$script:API_KEY = $API_KEY
# ====================== API ORCHESTRATION (lib/Api.ps1) ======================


# 5. Load Intelligence File
# ====================== LOAD INTELLIGENCE ======================
$configPath = Join-Path $scriptDir "instructions.json"
$script:intelligence = try {
    if (Test-Path $configPath) {
        $json = Get-Content $configPath -Raw | ConvertFrom-Json
        if ($null -eq $json.system_prompt) { throw "Invalid JSON structure" }
        $json
    } else { throw "File not found" }
} catch {
    [PSCustomObject]@{
        system_prompt = "You are Gemma, a helpful assistant."
        guardrails = @{ max_output_tokens = 8192; temperature = 0.7; top_p = 0.95 }
    }
}

# 6. Define Remaining Script Variables
# ====================== GUARDRAILS & STATUS ======================
$script:GUARDRAILS = @{ 
    maxOutputTokens = if ($script:intelligence.guardrails.max_output_tokens) { [int]$script:intelligence.guardrails.max_output_tokens } else { 8192 }; 
    temperature = if ($script:intelligence.guardrails.temperature) { [float]$script:intelligence.guardrails.temperature } else { 0.7 }; 
    topP = if ($script:intelligence.guardrails.top_p) { [float]$script:intelligence.guardrails.top_p } else { 0.95 } 
}
# $CONTEXT_WINDOW = 128000
$script:lastStatus   = @{ prompt = 0; candidate = 0; total = 0; finish = "" }
$script:lastApiCall        = (Get-Date).AddSeconds(-10)   # main loop Gemma calls
$script:lastApiCall_Gemini = (Get-Date).AddSeconds(-10)   # dual-agent Gemini calls
$script:apiCallLog_Gemma   = [System.Collections.Generic.List[datetime]]::new()  # Gemma RPM tracker
$script:apiCallLog_Gemini  = [System.Collections.Generic.List[datetime]]::new()  # Gemini RPM tracker (separate quota)

# ====================== SYSTEM PROMPT (lib/Api.ps1) ======================

# ====================== RATE LIMITING ======================
# ====================== API ORCHESTRATION (lib/Api.ps1) ======================

# ====================== DUAL-AGENT (lib/Api.ps1) ======================

function Initialize-ToolKeys {
    foreach ($tool in @($script:TOOLS.Values)) {
        if ($tool.RequiresKey) {
            $existing = Get-StoredKey -keyName $tool.Name
            if (-not $existing) {
                Write-Host "`n=== Tool Setup: $($tool.Name) ===" -ForegroundColor Cyan
                Write-Host "This tool requires an API key. Get it here:" -ForegroundColor Yellow
                Write-Host "$($tool.KeyUrl)`n" -ForegroundColor Gray
                Write-Host "(Press Escape to cancel and disable this tool)`n" -ForegroundColor DarkGray
                
                $cancelled = $false
                $plainKey = ""
                
                do {
                    $secureInput = Read-SecureStringWithCancel -Prompt "Enter API key for $($tool.Name)"
                    if ($null -eq $secureInput) { $cancelled = $true; break }
                    
                    $plainKey = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureInput))
                    
                    $confirm = Read-HostWithCancel -Prompt "Confirm API key (paste again)"
                    if ($null -eq $confirm) { $cancelled = $true; break }
                    
                    if ($plainKey -ne $confirm) { 
                        Write-Host "$CRS  Keys do not match. Try again." -ForegroundColor Red 
                        $plainKey = "" 
                    }
                    elseif ([string]::IsNullOrWhiteSpace($plainKey)) { 
                        Write-Host "$CRS  API key cannot be empty." -ForegroundColor Red 
                    }
                } while ($plainKey -ne $confirm -or [string]::IsNullOrWhiteSpace($plainKey))
                
                if ($cancelled) {
                    Write-Host "`nSetup cancelled. Disabling tool '$($tool.Name)'..." -ForegroundColor Yellow
                    if (Test-Path "tools\$($tool.Name).ps1") {
                        Move-Item -Path "tools\$($tool.Name).ps1" -Destination "more_tools/" -Force
                        $script:TOOLS.Remove($tool.Name)
                    }
                } else {
                    Save-StoredKey -apiKey $plainKey -keyName $tool.Name
                    Draw-Box @("$CHK  API key for '$($tool.Name)' saved securely.") -Color Green
                }
            }
        }
    }
}

function Update-SystemPrompt {
    param([bool]$resetHistory = $false)

    $toolBlock = Get-ToolInstructions -ScriptRoot $scriptDir -Model $script:MODEL -ToolLimits $script:TOOL_LIMITS
    $prompt = Get-SystemPrompt
    $prompt = $prompt -replace "%%AVAILABLE_TOOLS%%", $toolBlock
    
    # Initialize keys for any newly loaded/refreshed tools
    Initialize-ToolKeys
    
    # Onboarding Injection
    $onboarding = ""
    if ($script:TOOLS.ContainsKey("tutorial")) {
        $onboarding = "ONBOARDING: The 'tutorial' tool is active. You MUST call it immediately to receive your mission instructions for this session."
    }
    $prompt = $prompt -replace "%%ONBOARDING_NOTICE%%", $onboarding

    # Latent Awareness Injection
    $latent = ""
    if ($script:INACTIVE_COUNT -gt 0) {
        $latent = "SYSTEM NOTICE: There are currently $($script:INACTIVE_COUNT) inactive tools in your repository. If you encounter a request that requires a capability you do not currently possess, suggest that the user check '/settings' or '/tools disabled' to enable more capabilities."
    }
    $prompt = $prompt -replace "%%LATENT_AWARENESS_NOTICE%%", $latent

    $prompt = "[SYSTEM]: Current date and time: $(Get-Date -Format 'dddd, MMMM dd yyyy HH:mm')`n`n" + $prompt
    $script:systemPrompt = $prompt

    if ($resetHistory -or $null -eq $script:history -or $script:history.Count -eq 0) {
        $script:history = @( 
            @{ role = "user"; parts = @(@{ text = $script:systemPrompt }) },
            @{ role = "model"; parts = @(@{ text = "Acknowledged. Gemma CLI [SYSTEM] protocols active. Standing by for instructions." }) }
        )
    } else {
        # Update index 0 (system instructions) without wiping conversation turns
        $script:history[0].parts[0].text = $script:systemPrompt
    }
}

# Initial build
Update-SystemPrompt

# ====================== LOAD MEMORY ======================
$appDataGemma = Join-Path $env:APPDATA "GemmaCLI"
$memoryFile   = Join-Path $appDataGemma "memory.json"
$script:historyFile = Join-Path $appDataGemma "last_session.json"

# ====================== LOAD CUSTOM COMMANDS ======================
$customCommandsPath = Join-Path $scriptDir "config/custom_commands.json"
$script:customCommands = @{}
if (Test-Path $customCommandsPath) {
    $jsonObject = Get-Content -Path $customCommandsPath | ConvertFrom-Json
    $hashtable = @{}
    if ($jsonObject) {
        foreach ($property in $jsonObject.PSObject.Properties) {
            $hashtable[$property.Name] = $property.Value
        }
    }
    $script:customCommands = $hashtable
}

# ====================== COLOR SCHEMES ======================
$script:DefaultColors = @{
    input_highlight = "DarkMagenta"
    input_text      = "Gray"
    gemma_response  = "Green"
    ui_boxes        = "Cyan"
    system_status   = "Cyan"
    user_label      = "Gray"
    custom_command  = "Magenta"
}

$script:AlternativeColors = @{
    input_highlight = "DarkBlue"
    input_text      = "White"
    gemma_response  = "Yellow"
    ui_boxes        = "Cyan"
    system_status   = "Cyan"
    user_label      = "White"
    custom_command  = "Cyan"
}

$scheme = if ($script:Settings.color_scheme) { $script:Settings.color_scheme } else { "default" }

if ($scheme -eq "alternative") {
    $script:Colors = $script:AlternativeColors
} else {
    $script:Colors = $script:DefaultColors
}

# ====================== CONTEXT MODE INIT ======================
$contextMode = if ($script:Settings.context_mode) { $script:Settings.context_mode } else { "standard" }
if ($contextMode -eq "large") {
    $script:CONTEXT_LIMIT = 128000
    $script:TRIM_THRESHOLD = 60000
} else {
    $script:CONTEXT_LIMIT = 15000
    $script:TRIM_THRESHOLD = 11000
}

# ====================== SPLASH ======================
$startupDelay = if ($script:Settings.startup_delay) { [int]$script:Settings.startup_delay } else { 0 }
if ($startupDelay -gt 0) { Start-Sleep -Seconds $startupDelay }
Clear-Host
Write-Host ""
Write-Host "  .oooooo.   oooooooooooo ooo        ooooo ooo        ooooo      .o.       " -ForegroundColor Magenta
Write-Host " d8P'  'Y8b  '888'     '8 '88.       .888' '88.       .888'     .888.      " -ForegroundColor Magenta
Write-Host "888           888          888b     d'888   888b     d'888      .8'888.     " -ForegroundColor Magenta
Write-Host "888           888oooo8     8 Y88. .P  888   8 Y88. .P  888     .8' '888.   " -ForegroundColor Magenta
Write-Host "888     ooooo 888    '     8  '888'   888   8  '888'   888    .88ooo8888.  " -ForegroundColor Magenta
Write-Host "'88.    .88'  888       o  8    Y     888   8    Y     888   .8'     '888. " -ForegroundColor Magenta
Write-Host " 'Y8bood8P'  o888ooooood8 o8o        o888o o8o        o888o o88o     o8888o" -ForegroundColor Magenta
Write-Host ""

$helpLines = @(
    "/help              $ARR Show all commands",
    "/clear             $ARR Reset conversation",
    "/speak [m/f]       $ARR Toggle Text-to-Speech (TTS) output",
    "/listen            $ARR Enable Speech-to-Text (STT) input",
    "/recall            $ARR Load memories from previous sessions",
    "/resume            $ARR Resume last conversation session",
    "/multiline         $ARR Multiline mode - end with /end",
    "/refresh           $ARR Hot-reload tools and system prompt",
    "/model [id]        $ARR Switch model / pass id directly",
    "/tools [all]       $ARR Show enabled/disabled/all tools",
    "/settings          $ARR Manage system settings",
    "/customCommand     $ARR List/Create your custom commands",
    "/bigBrother [q]    $ARR Dual model pipeline, Gemini > Gemma > Gemini",
    "/littleSister [q]  $ARR Dual model pipeline, Gemma > Gemini > Gemma",
    "/debug             $ARR Toggle debug output",
    "/trim              $ARR Force manual context trim",
    "/resetkey          $ARR Delete saved key & re-prompt",
    "/exit              $ARR Quit"
)

Draw-Box $helpLines -Title "Gemma CLI v0.8.1 $BUL (C) 2026 SpdrByte Labs $BUL AGPL-3.0 License" -Width 80 -Color $script:Colors.ui_boxes

Write-Host ""

# ====================== MAIN LOOP ======================
while ($true) {
    # Dark Purple Entire Row Highlight for Input
    $esc = [char]27
    # Map friendly color names to ANSI if needed, but for now we'll stick to basic colors or keep the purple logic
    # The requirement was "don't reuse same colors", so let's use the scheme's highlight
    $bgRGB = if ($scheme -eq "alternative") { "0;0;100" } else { "40;0;40" } 
    $highlightColor = "$esc[48;2;$($bgRGB)m" 
    $reset = "$esc[0m"

    # Write the row start and header
    Write-Host "$highlightColor$($esc)[K You" -NoNewline -ForegroundColor $script:Colors.user_label
    
    # 1. Print bar AFTER user prompt line always.
    $startX = [Console]::CursorLeft
    $startY = [Console]::CursorTop
    
    # Ensure there is a line below for the bar if we are at the bottom
    if ($startY -ge ([Console]::BufferHeight - 1)) {
        [Console]::WriteLine()
        $startY--
        [Console]::SetCursorPosition($startX, $startY)
    }

    $barRow = $startY + 1
    [Console]::SetCursorPosition(0, $barRow)
    $text = Get-StatusBarText
    $w = [Console]::WindowWidth
    $paddedText = if ($text.Length -gt ($w - 1)) { $text.Substring(0, $w - 1) } else { $text.PadRight($w - 1) }
    Write-Host $paddedText -ForegroundColor $script:Colors.system_status -BackgroundColor DarkBlue -NoNewline
    
    # Return cursor to prompt position for user to type
    [Console]::SetCursorPosition($startX, $startY)

    # Start polling tracker — moves bar down if user input wraps to new line
    Start-BarTracker -InitialBarRow $barRow -HighlightANSI $highlightColor

    # Use the ANSI code as a prefix for Read-Host to keep the background purple while typing
    $userInput = Read-Host "$highlightColor"

    $endY = [Console]::CursorTop
    Write-Host -NoNewline $reset # Reset immediately after enter

    # Stop tracker, get final bar row, erase it
    Stop-BarTracker
    $finalBarRow = $script:barRow
    if ($finalBarRow -lt [Console]::BufferHeight) {
        [Console]::SetCursorPosition(0, $finalBarRow)
        Write-Host (" " * ($w - 1)) -NoNewline
        [Console]::SetCursorPosition(0, $endY)
    }

    if ($userInput -eq "exit" -or $userInput -eq "/exit") { break }


     if ($userInput -eq "/multiline") {
        $pastelines =@()
        Write-Host "Multiline mode - [end with /end on its own line]" -ForegroundColor DarkGray
        while ($true) {
            $pasteline = Read-Host
            if ($pasteline -eq "/end") { break }
            $pastelines += $pasteline
        }
        $userInput = $pastelines -join "`n"
    }


    if ($userInput -eq "/clear") {
        $script:history = @($script:history[0])
        Draw-Box @("$CHK  Conversation cleared.") -Color Yellow
        continue
    }

    if ($userInput -match '^/speak\s*(.*)$') {
        $arg = $matches[1].Trim().ToLower()
        
        if ($arg -eq "male" -or $arg -eq "m" -or $arg -eq "female" -or $arg -eq "f") {
            $script:ttsEnabled = $true
            $voiceName = if ($arg -eq "male" -or $arg -eq "m") { "Microsoft David Desktop" } else { "Microsoft Zira Desktop" }
            $label = if ($arg -eq "male" -or $arg -eq "m") { "David (Male)" } else { "Zira (Female)" }

            if (Initialize-TTS) {
                try {
                    $global:GemmaTTS.SelectVoice($voiceName)
                    Draw-Box @("$CHK  Text-to-Speech ON (Voice: $label)") -Color Magenta
                } catch {
                    Write-Host "  [!] Voice '$voiceName' not found." -ForegroundColor Red
                }
            }
            continue
        }

        # Original toggle logic
        $script:ttsEnabled = -not $script:ttsEnabled
        $state = if ($script:ttsEnabled) { "ON" } else { "OFF" }
        Draw-Box @("$CHK  Text-to-Speech $state") -Color Magenta
        
        # Initialize if turning on
        if ($script:ttsEnabled) { Initialize-TTS | Out-Null }
        continue
    }

    if ($userInput -eq "/debug") {
        $script:debugMode = -not $script:debugMode
        $state = if ($script:debugMode) { "ON" } else { "OFF" }
        Draw-Box @("$CHK  Debug mode $state") -Color Yellow
        continue
    }

    if ($userInput -eq "/trim") {
        $script:history = Invoke-SmartTrim -hist $script:history -tokenBudget $script:TRIM_THRESHOLD
        Draw-Box @("$CHK  Manual context trim completed.") -Color Magenta
        continue
    }

    if ($userInput -eq "/refresh") {
        Update-SystemPrompt
        Draw-Box @("$CHK  Tools and system prompt reloaded.", "     Current enabled tools: $($script:TOOLS.Count)") -Color Green
        continue
    }

    if ($userInput -eq "/help") {
        Draw-Box $helpLines -Title "Gemma CLI  $BUL  Help" -Width 80 -Color $script:Colors.ui_boxes
        continue
    }

    if ($userInput -eq "/listen") {
        try {
            Add-Type -AssemblyName System.Speech
            $recognizer = New-Object System.Speech.Recognition.SpeechRecognitionEngine
            $recognizer.SetInputToDefaultAudioDevice()
            $recognizer.LoadGrammar((New-Object System.Speech.Recognition.DictationGrammar))
            
            # Give the user more time to think and speak
            $recognizer.InitialSilenceTimeout = [TimeSpan]::FromSeconds(10)
            $recognizer.EndSilenceTimeout = [TimeSpan]::FromSeconds(3)

            Write-Host "`n  [LISTENING...] " -NoNewline -ForegroundColor Yellow
            $sttResult = $recognizer.Recognize([TimeSpan]::FromSeconds(60))
            
            if ($sttResult) {
                $rawText = $sttResult.Text
                $confidence = [Math]::Round($sttResult.Confidence, 2)
                
                if ($script:debugMode) {
                    Write-Host " [STT Confidence: $confidence] " -NoNewline -ForegroundColor Yellow
                }
                
                Write-Host $rawText -ForegroundColor Green
                
                # Tag the input so Gemma knows to be lenient with transcription errors
                $userInput = "[VOICE STT (Confidence: $confidence)]: $rawText"
            } else {
                Write-Host "No speech detected." -ForegroundColor Red
                continue
            }
        } catch {
            Write-Host "  [!] STT Error: $($_.Exception.Message)" -ForegroundColor Red
            continue
        } finally {
            if ($recognizer) { $recognizer.Dispose() }
        }
    }


    if ($userInput -eq "/recall") {
        if (-not (Test-Path $memoryFile)) {
            Draw-Box @("$CRS  No memory file found. Ask Gemma to remember something first.") -Color Yellow
            continue
        }

        try {
            $raw      = Get-Content $memoryFile -Raw -Encoding UTF8
            $memories = $raw | ConvertFrom-Json

            if (-not $memories -or $memories.Count -eq 0) {
                Draw-Box @("$CRS  Memory file is empty.") -Color Yellow
                continue
            }

            $lines    = @()
            $lines   += "RECALLED MEMORIES ($($memories.Count) entries):"
            $lines   += ""
            $grouped  = $memories | Group-Object -Property category | Sort-Object Name
            foreach ($group in $grouped) {
                $lines += "[$($group.Name.ToUpper())]"
                foreach ($m in $group.Group) {
                    $lines += "  $($m.date)  $($m.fact)"
                }
                $lines += ""
            }

            $script:history += @{
                role  = "user"
                parts = @(@{ text = "MEMORY CONTEXT - facts you have learned about me in previous sessions:`n`n$($lines -join "`n")`n`nAcknowledge this context briefly and use it going forward." })
            }

            $boxLines = @("$CHK  Loaded $($memories.Count) memories into context", "")
            foreach ($group in $grouped) {
                $boxLines += "  $($group.Name.ToUpper()) ($($group.Group.Count))"
                foreach ($m in $group.Group) {
                    $preview   = if ($m.fact.Length -gt 55) { $m.fact.Substring(0, 55) + "..." } else { $m.fact }
                    $boxLines += "    $($m.date.Substring(0,10))  $preview"
                }
            }
            Draw-Box $boxLines -Title "/recall  $BUL  Memory Loaded" -Width 80 -Color Magenta

        } catch {
            Draw-Box @("$CRS  Failed to load memory: $($_.Exception.Message)") -Color Red
        }
        continue
    }

    if ($userInput -eq "/resume") {
        if (-not (Test-Path $script:historyFile)) {
            Draw-Box @("$CRS  No previous session history found.") -Color Yellow
            continue
        }

        try {
            $raw = Get-Content $script:historyFile -Raw -Encoding UTF8
            $savedHistory = $raw | ConvertFrom-Json
            
            # Reconstruct history into proper format (hashtables)
            $script:history = @()
            foreach ($turn in $savedHistory) {
                $turnHash = @{ role = $turn.role; parts = @() }
                foreach ($part in $turn.parts) {
                    $partHash = @{}
                    if ($part.text) { $partHash["text"] = $part.text }
                    if ($part.inline_data) { 
                        $partHash["inline_data"] = @{ 
                            mime_type = $part.inline_data.mime_type
                            data = $part.inline_data.data 
                        }
                    }
                    $turnHash.parts += $partHash
                }
                $script:history += $turnHash
            }

            Draw-Box @("$CHK  Resumed last session history ($($script:history.Count) turns).") -Color Green
        } catch {
            Draw-Box @("$CRS  Failed to resume session: $($_.Exception.Message)") -Color Red
        }
        continue
    }


    if ($userInput -match '^/tools\s*(.*)$') {
        $sub = $matches[1].Trim().ToLower()
        $mode = "enabled"
        if ($sub -eq "all") { $mode = "all" }
        elseif ($sub -eq "disabled") { $mode = "disabled" }
        
        $title = switch ($mode) {
            "all"      { "All Repository Tools (Enabled & Disabled)" }
            "disabled" { "Disabled Tools (more_tools/)" }
            default    { "Active Tools (Enabled)" }
        }

        $toolLines = Get-ToolsSummary -ScriptRoot $scriptDir -Mode $mode
        $wikiPath = Join-Path $scriptDir "TOOLS.html"
        $toolLines += ""
        $toolLines += "  $BUL  Tool Docs: $(Convert-ToHyperlink -Text $wikiPath)"
        Draw-Box $toolLines -Title $title -Width 90 -Color Green
        continue
    }

    if ($userInput -eq "/resetkey") {
        if (Remove-StoredKey -keyName "gemmacli") {
            Draw-Box @("$CHK  Saved API key deleted. Restart the script to set a new one.") -Color Cyan
        } else {
            Draw-Box @("$CRS  No saved API key found to delete.") -Color Yellow
        }
        break
    }

    if ($userInput -eq "/settings") {
        $settingsChoice = Show-ArrowMenu -Options @("Colors", "Tools", "Smart Trim", "Context Mode", "Start Delay", "Exit") -Title "Settings"
        switch ($settingsChoice) {
            0 { 
                $schemeOptions = @("Default Scheme", "Alternative Scheme")
                $schemeIdx = if ($scheme -eq "alternative") { 1 } else { 0 }
                $choice = Show-ArrowMenu -Options $schemeOptions -Title "Color Settings" -Default $schemeIdx
                if ($choice -ge 0) {
                    $newScheme = if ($choice -eq 1) { "alternative" } else { "default" }
                    $script:Settings.color_scheme = $newScheme
                    $script:Settings | ConvertTo-Json | Set-Content -Path $settingsPath
                    Draw-Box @("Color scheme updated to '$newScheme'. Restart the script to apply changes.") -Color Yellow
                }
            }
            1 { 
                $enabledTools = @(Get-ChildItem -Path "tools" -Filter "*.ps1" | ForEach-Object { @{ Name = $_.BaseName; Status = "Enabled" } })
                $disabledTools = @(Get-ChildItem -Path "more_tools" -Filter "*.ps1" | ForEach-Object { @{ Name = $_.BaseName; Status = "Disabled" } })
                $allTools = $enabledTools + $disabledTools
                
                $pageSize = 12
                $pageIdx = 0
                
                while ($true) {
                    $startIdx = $pageIdx * $pageSize
                    $endIdx = [math]::Min($startIdx + $pageSize - 1, $allTools.Count - 1)
                    $currentPageTools = $allTools[$startIdx..$endIdx]

                    $toolOptions = $currentPageTools | ForEach-Object { 
                        $meta = $script:TOOL_CACHE[$_.Name]

                        $inds = @()
                        if ($meta.Interactive) { $indicators += "⚠ " }
                        if ($meta.RequiresKey) { $indicators += "🔑" }
                        $indStr = if ($inds.Count -gt 0) { " " + ($inds -join " ") } else { "" }

                        "$($meta.Icon) $($_.Name)$indStr ($($_.Status))" 
                    }

                    
                    $hasPrev = $pageIdx -gt 0
                    $hasNext = ($startIdx + $pageSize) -lt $allTools.Count
                    
                    if ($hasPrev) { $toolOptions += "< Previous Page" }
                    if ($hasNext) { $toolOptions += "> Next Page" }
                    $toolOptions += "[ Exit ]"
                    
                    $totalPages = [math]::Ceiling($allTools.Count / $pageSize)
                    $titleStr = "Tool Management  $BUL  Page $($pageIdx + 1) of $totalPages"
                    
                    $toolChoice = Show-ArrowMenu -Options $toolOptions -Title $titleStr
                    if ($toolChoice -lt 0) { break } # Esc pressed
                    
                    $selectedStr = $toolOptions[$toolChoice]
                    if ($selectedStr -eq "[ Exit ]") { break }
                    elseif ($selectedStr -eq "< Previous Page") { $pageIdx--; continue }
                    elseif ($selectedStr -eq "> Next Page") { $pageIdx++; continue }
                    
                    # They selected an actual tool
                    $selectedTool = $currentPageTools[$toolChoice]
                    $enabledCount = @($allTools | Where-Object { $_.Status -eq "Enabled" }).Count
                    $limit = $script:TOOL_LIMITS[$script:MODEL]

                    if ($selectedTool.Status -eq "Disabled" -and $enabledCount -ge $limit) {
                        Draw-Box @("Model '$($script:MODEL)' only supports $limit active tools. Please disable a tool before enabling another.") -Color Red
                    } else {
                        if ($selectedTool.Status -eq "Enabled") {
                            Move-Item -Path "tools\$($selectedTool.Name).ps1" -Destination "more_tools/"
                            $script:Settings | ConvertTo-Json | Set-Content -Path $settingsPath
                            Update-SystemPrompt
                            Draw-Box @("Tool '$($selectedTool.Name)' disabled.") -Color Yellow
                        } else {
                            Move-Item -Path "more_tools\$($selectedTool.Name).ps1" -Destination "tools/"
                            $script:Settings | ConvertTo-Json | Set-Content -Path $settingsPath
                            Update-SystemPrompt
                            # Check if tool is still active (it might have been disabled during key setup)
                            if ($script:TOOLS.ContainsKey($selectedTool.Name)) {
                                Draw-Box @("Tool '$($selectedTool.Name)' enabled.") -Color Yellow
                            } else {
                                Draw-Box @("Tool '$($selectedTool.Name)' disabled (Setup cancelled).") -Color Yellow
                            }
                        }
                    }
                    break # Exit the loop after toggling
                }
            }
            2 {
                $currentEnabled  = if ($null -ne $script:Settings.smart_trim) { [bool]$script:Settings.smart_trim } else { $false }
                $currentStrength = if ($script:Settings.smart_trim_strength) { [int]$script:Settings.smart_trim_strength } else { 5 }
                $trimState       = if ($currentEnabled) { "Enabled" } else { "Disabled" }

                $trimChoice = Show-ArrowMenu -Options @("Toggle Smart Trim ($trimState)", "Set Strength ($currentStrength)") -Title "Smart Trim Settings"

                if ($trimChoice -eq 0) {
                    $script:Settings.smart_trim = -not $currentEnabled
                    $script:Settings | ConvertTo-Json | Set-Content -Path $settingsPath
                    $newState = if ($script:Settings.smart_trim) { "Enabled" } else { "Disabled" }
                    Draw-Box @("$CHK  Smart Trim $newState") -Color Magenta
                }
                elseif ($trimChoice -eq 1) {
                    $strengthOptions = @(
                        "1  - Conservative  (keep most, minimal token savings)",
                        "2  - Conservative+",
                        "3  - Balanced-",
                        "4  - Balanced",
                        "5  - Balanced+  (recommended)",
                        "6  - Aggressive-",
                        "7  - Aggressive",
                        "8  - Aggressive+",
                        "9  - Maximum-",
                        "10 - Maximum  (keep least, most token savings)"
                    )
                    $strengthIdx    = [math]::Max(0, $currentStrength - 1)
                    $strengthChoice = Show-ArrowMenu -Options $strengthOptions -Title "Smart Trim Strength" -Default $strengthIdx
                    if ($strengthChoice -ge 0) {
                        $script:Settings.smart_trim_strength = $strengthChoice + 1
                        $script:Settings | ConvertTo-Json | Set-Content -Path $settingsPath
                        Draw-Box @("$CHK  Smart Trim strength set to $($script:Settings.smart_trim_strength)") -Color Magenta
                    }
                }
            }
            3 {
                $currentMode = if ($script:Settings.context_mode) { $script:Settings.context_mode } else { "standard" }
                $defaultIdx = if ($currentMode -eq "large") { 1 } else { 0 }
                $modeChoice = Show-ArrowMenu -Options @("Standard (15k - Google API)", "Large (128k - Enterprise/Paid)") -Title "Select Context Mode" -Default $defaultIdx
                if ($modeChoice -ge 0) {
                    $script:Settings.context_mode = if ($modeChoice -eq 1) { "large" } else { "standard" }
                    $script:Settings | ConvertTo-Json | Set-Content -Path $settingsPath
                    Draw-Box @("Context mode set to '$($script:Settings.context_mode)'. Restart GemmaCLI to apply.") -Color Magenta
                }
            }
            4 {
                $currentDelay = if ($script:Settings.startup_delay) { [int]$script:Settings.startup_delay } else { 0 }
                $delayOptions = @("0s  - No delay", "1s", "2s", "3s", "5s")
                $delayValues  = @(0, 1, 2, 3, 5)
                $currentIdx   = [math]::Max(0, $delayValues.IndexOf($currentDelay))
                $delayChoice  = Show-ArrowMenu -Options $delayOptions -Title "Startup Delay  $BUL  current: $($currentDelay)s" -Default $currentIdx
                if ($delayChoice -ge 0) {
                    $script:Settings.startup_delay = $delayValues[$delayChoice]
                    $script:Settings | ConvertTo-Json | Set-Content -Path $settingsPath
                    Draw-Box @("$CHK  Startup delay set to $($delayValues[$delayChoice])s") -Color Magenta
                }
            }
        }
        continue
    }

    if ($userInput -eq "/customCommand") {
        $lines = @(
            "HOW TO CREATE A CUSTOM COMMAND:",
            "Use the syntax: /customCommand /yourAlias Your detailed prompt here",
            "Example: /customCommand /poem write a short poem about coding",
            "",
            "Once created, you can just type /yourAlias to execute that prompt.",
            ""
        )

        if ($script:customCommands.Count -gt 0) {
            $lines += "YOUR CUSTOM COMMANDS:"
            foreach ($key in $script:customCommands.Keys) {
                $lines += "$($key.PadRight(18)) $ARR  $($script:customCommands[$key])"
            }
        } else {
            $lines += "You haven't created any custom commands yet."
        }

        Draw-Box $lines -Title "Custom Commands Management" -Width 80 -Color $script:Colors.custom_command
        continue
    }

    if ($userInput -match '^/customCommand\s+(\/\w+)\s+(.*)') {
        $alias = $matches[1]
        $prompt = $matches[2]
        
        $script:customCommands[$alias] = $prompt
        $script:customCommands | ConvertTo-Json | Set-Content -Path $customCommandsPath
        
        Draw-Box @("Custom command '$alias' has been saved and is ready to use.") -Color Green
        continue
    }

    # ---- /model command ----
    if ($userInput -match '^/model\s*(.*)$') {
        $modelArg = $matches[1].Trim()

        # Strictly allowed handles for the Chat Model Picker
        $gemmaHandles = @("gemma-4-pro", "gemma-4-fast", "gemma-ultra", "gemma-heavy", "gemma-medium", "gemma-small", "gemma-nano-pro", "gemma-nano-lite")
        $availableGemma = @()
        foreach ($handle in $gemmaHandles) {
            $p = $script:MODEL_REGISTRY.PSObject.Properties[$handle]
            if ($p -and $p.Value.id) { $availableGemma += $p }
        }

        if ([string]::IsNullOrWhiteSpace($modelArg)) {
            # UI shows Checkmark (if current), ID, and Description in aligned columns
            $menuLabels = $availableGemma | ForEach-Object {
                $e = $_.Value
                $isCurrent = ($_.Name -eq $script:MODEL_HANDLE)
                $prefix = if ($isCurrent) { "$CHK " } else { "  " }
                "$prefix $($e.id.PadRight(25)) $ARR  $($e.desc)"
            }
            
            $currentIdx = 0
            for ($i = 0; $i -lt $availableGemma.Count; $i++) {
                if ($availableGemma[$i].Name -eq $script:MODEL_HANDLE) { $currentIdx = $i; break }
            }

            $choice = Show-ArrowMenu -Options $menuLabels -Title "Select Gemma Model  $BUL  $WRN Warning: Changing model clears context" -Width 110 -Default $currentIdx
            
            if ($choice -ge 0) {
                $selected = $availableGemma[$choice]
                $script:MODEL_HANDLE = $selected.Name
                $script:MODEL = $selected.Value.id
                $script:Settings.current_model_handle = $script:MODEL_HANDLE
                $script:Settings | ConvertTo-Json | Set-Content $settingsPath
                
                # Check tool limits and disable excess tools
                $limit = if ($script:TOOL_LIMITS[$script:MODEL] -ne $null) { $script:TOOL_LIMITS[$script:MODEL] } else { 0 }
                $enabledTools = Get-ChildItem -Path "tools" -Filter "*.ps1" | Sort-Object Name
                if ($enabledTools.Count -gt $limit) {
                    $toDisable = $enabledTools.Count - $limit
                    $disabledNames = @()
                    for ($i = 0; $i -lt $toDisable; $i++) {
                        $tool = $enabledTools[$enabledTools.Count - 1 - $i]
                        Move-Item -Path $tool.FullName -Destination "more_tools/" -Force
                        $disabledNames += $tool.BaseName
                    }
                    Draw-Box @("$WRN  Tool limit for '$($script:MODEL)' is $limit.", "     Disabled excess tools: $($disabledNames -join ', ')") -Color Yellow
                }

                Update-SystemPrompt -resetHistory $true
                Draw-Box @("$CHK  Model switched to: $script:MODEL", "$WRN  Conversation context has been cleared.") -Color Magenta
            } else {
                Write-Host "  Model selection cancelled." -ForegroundColor DarkGray
            }
        } else {
            # Direct switch: check if input matches a Gemma ID or Handle
            $found = $availableGemma | Where-Object { $_.Name -eq $modelArg -or $_.Value.id -eq $modelArg }
            if ($found) {
                $script:MODEL_HANDLE = $found.Name
                $script:MODEL = $found.Value.id
                $script:Settings.current_model_handle = $script:MODEL_HANDLE
                $script:Settings | ConvertTo-Json | Set-Content $settingsPath
                Update-SystemPrompt
                Draw-Box @("$CHK  Model switched to: $script:MODEL") -Color Magenta
            } else {
                Write-Host "  [!] Unknown or restricted Gemma model '$modelArg'." -ForegroundColor Red
            }
        }
        continue
    }

    # ---- /bigBrother command ----
    if ($userInput -match '^/bigBrother\s+(.+)$') {
        $query = $matches[1].Trim()
        Invoke-DualAgent -query $query -mode "bigBrother"
        continue
    }

    if ($userInput -eq "/bigBrother") {
        Draw-Box @("$CRS  Usage: /bigBrother <your question>") -Color Yellow
        continue
    }

    # ---- /littleSister command ----
    if ($userInput -match '^/littleSister\s+(.+)$') {
        $query = $matches[1].Trim()
        Invoke-DualAgent -query $query -mode "littleSister"
        continue
    }

    if ($userInput -eq "/littleSister") {
        Draw-Box @("$CRS  Usage: /littleSister <your question>") -Color Yellow
        continue
    }

    if ($script:customCommands.ContainsKey($userInput)) {
        $userInput = $script:customCommands.$userInput
        Draw-Box @("Executing custom command: $userInput") -Color $script:Colors.custom_command
    }

    if ([string]::IsNullOrWhiteSpace($userInput)) { 
        # Move up one line and clear it to remove the dangling "You:" prompt
        Write-Host "$esc[1A$esc[K" -NoNewline
        continue 
    }

    $script:history += @{ role = "user"; parts = @(@{ text = $userInput }) }

    $currentUri = Get-ApiUri 
    $toolTurns    = 0
    $defaultMax   = if ($script:MODEL -in @("gemma-4-31b-it","gemma-4-26b-a4b-it","gemma-3-27b-it","gemma-3-12b-it")) { 8 } else { 4 }
    $maxToolTurns = if ($script:Settings.max_tool_turns) { [int]$script:Settings.max_tool_turns } else { $defaultMax }

    while ($true) {
        # RPM check — enforces free-tier request-per-minute ceiling before every call
        Invoke-RpmCheck -backend "gemma"

        # Minimum 2-second gap between calls (secondary guard, covers sub-RPM burst)
        if ($script:lastApiCall) {
            $elapsed = ((Get-Date) - $script:lastApiCall).TotalMilliseconds
            if ($elapsed -lt 2000) { Start-Sleep -Milliseconds (2000 - $elapsed) }
        }
        $script:lastApiCall = Get-Date

        # Trim history if approaching context window limit
        $script:history = Invoke-SmartTrim -hist $script:history -tokenBudget $script:TRIM_THRESHOLD -currentQuery $userInput

        # Start spinner ONLY for the API call to avoid interfering with tool logic
        Start-Spinner -Label "Gemma is thinking (Esc to cancel)"

        $resp = Invoke-GemmaApiWithRetry -uri $currentUri -historyRef ([ref]$script:history) -gConfig $script:GUARDRAILS

        Stop-Spinner 

        if ($resp.cancelled) {
            Write-Host " [Operation cancelled by user]" -ForegroundColor Yellow
            break
        }

        if (-not $resp) {
            Write-Host ""
            Draw-Box @("$CRS  No response from API. Check your connection or API key.") -Color Red
            break
        }
        if ($resp.apiError) {
            $errMsg = $resp.apiError
            Write-Host ""
            Draw-Box @("$CRS  API Error:", "     $errMsg") -Color Red
            break
        }
        if (-not $resp.candidates) {
            $reason = if ($resp.promptFeedback.blockReason) { $resp.promptFeedback.blockReason } else { "Unknown reason" }
            Write-Host ""
            Draw-Box @("$CRS  Response blocked: $reason") -Color Red
            break
        }

        # Update metadata for next status bar draw
        $usage = $resp.usageMetadata
        $fin   = $resp.candidates[0].finishReason

        # Handle plural/singular inconsistency and missing candidate data in Google's API schema
        $cCount = if ($usage.candidatesTokenCount) { $usage.candidatesTokenCount } 
                  elseif ($usage.candidateTokenCount) { $usage.candidateTokenCount }
                  elseif ($usage.totalTokenCount -and $usage.promptTokenCount) { 
                      [math]::Max(0, [int]$usage.totalTokenCount - [int]$usage.promptTokenCount) 
                  }
                  else { 0 }

        $tCount = if ($usage.totalTokenCount -and $usage.totalTokenCount -gt 0) { $usage.totalTokenCount } 
                  else { ([int]$usage.promptTokenCount + [int]$cCount) }

        if ($script:debugMode) {
            Write-Host " [Meta] candidatesTokenCount=$($usage.candidatesTokenCount) candidateTokenCount=$($usage.candidateTokenCount) total=$($usage.totalTokenCount) -> resolved: cand=$cCount total=$tCount" -ForegroundColor DarkYellow
        }

        $script:lastStatus = @{ prompt = $usage.promptTokenCount; candidate = $cCount; total = $tCount; finish = $fin }
        Write-ApiLog -toolName "chat"  # updated to tool name below if a tool call is parsed

        $modelText = ""
        foreach ($p in $resp.candidates[0].content.parts) {
            if ($p.thought -eq $true) {
                $modelText += "<thought>`n" + $p.text.Trim() + "`n</thought>`n"
            } elseif ($p.text) {
                $modelText += $p.text + "`n"
            }
        }
        $modelText = $modelText.Trim()

        if ([string]::IsNullOrWhiteSpace($modelText) -and -not $resp.candidates[0].content.parts.tool_calls) {
             # Only show error if no tool call was parsed elsewhere
             Write-Host ""
             Draw-Box @("$CRS  Empty response received. This may be a safety block or API glitch.") -Color Red
             break
        }
        function Render-ModelText {
            param([string]$text)
            Write-Host ""
            Write-Host " Gemma: " -NoNewline -ForegroundColor $script:Colors.gemma_response
            
            # Support both <thought> tags and native <|channel>thought tags
            $segments = [System.Text.RegularExpressions.Regex]::Split($text, '(?s)(<thought>.*?</thought>|<\|channel>thought.*?<channel\|>)')
            foreach ($seg in $segments) {
                if ($seg -match '(?s)<thought>(.*?)</thought>' -or $seg -match '(?s)<\|channel>thought(.*?)<channel\|>') {
                    $thought = $matches[1].Trim()
                    Write-Host "`n  [THINKING]: " -NoNewline -ForegroundColor Gray
                    Write-Host $thought -ForegroundColor DarkGray
                    Write-Host ""
                } else {
                    # Split remaining text by code blocks
                    $subSegments = [System.Text.RegularExpressions.Regex]::Split($seg, '(?s)(<code_block>.*?</code_block>)')
                    foreach ($sub in $subSegments) {
                        if ($sub -match '(?s)<code_block>(.*?)</code_block>') {
                            $code = $matches[1].Trim()
                            Write-Host ""
                            foreach ($codeLine in $code -split "`n") {
                                Write-Host "  $codeLine" -ForegroundColor White -BackgroundColor DarkGray
                            }
                            Write-Host ""
                        } else {
                             if ($sub.Trim()) { 
                                $hyperlinked = Convert-ToHyperlink -Text $sub
                                Write-Host $hyperlinked 
                             }
                        }
                    }
                }
            }
            Write-Host ""
        }

        $jsonStr = $null
        $preText = $null
        $strippedText = $modelText -replace '(?s)<code_block>.*?</code_block>', '[code block]'
        $strippedText = $strippedText -replace '(?s)<thought>.*?</thought>', '[thought]'
        $strippedText = $strippedText -replace '(?s)<\|channel>thought.*?<channel\|>', '[thought]'

        # Format 1: Official XML style <tool_call>{...}</tool_call>
        if ($strippedText -match '(?s)(.*?)<tool_call>\s*(\{.*?\})\s*</tool_call>') {
            $preText = $matches[1].Trim(); $jsonStr = $matches[2]
        }
        # Format 2: Markdown style ```tool_code\n{...}\n```
        elseif ($strippedText -match '(?s)(.*?)```tool_code\s*(\{.*?\})\s*```' -and $strippedText -notmatch '(?s)```[^`]*```tool_code') {
            $preText = $matches[1].Trim(); $jsonStr = $matches[2]
        }
        # Format 3: Codefence style ```tool_call\n{...}\n```
        elseif ($strippedText -match '(?s)(.*?)```tool_call\s*(\{.*?\})\s*```' -and $strippedText -notmatch '(?s)```[^`]*```tool_call') {
            $preText = $matches[1].Trim(); $jsonStr = $matches[2]
        }
        # Format 4: Plain ```json\n{...}\n``` with a name field
        elseif ($strippedText -match '(?s)(.*?)```json\s*(\{.*?"name".*?\})\s*```' -and $strippedText -notmatch '(?s)```[^`]*```json') {
            $preText = $matches[1].Trim(); $jsonStr = $matches[2]
        }
        # Format 5: Bare function call style tool_name({"param": "value"})
        elseif ($strippedText -match '(?s)(.*?)(\w+)\(\s*(\{.*?\})\s*\)') {
            $preText = $matches[1].Trim(); $jsonStr = "{`"name`": `"$($matches[2])`", `"parameters`": $($matches[3])}"
        }
        # Format 6: Expanded XML tags <tool_call><name>...</name><parameters>...</parameters></tool_call>
        elseif ($strippedText -match '(?s)(.*?)<tool_call>\s*<name>(.*?)</name>\s*<parameters>(.*?)</parameters>\s*</tool_call>') {
            $preText = $matches[1].Trim()
            $tName = $matches[2].Trim()
            $tParams = $matches[3].Trim()
            # Convert simple XML parameters to JSON if possible, or wrap as string
            $jsonStr = "{`"name`": `"$tName`", `"parameters`": $tParams}"
        }

        if ($jsonStr) {
            if ($preText) { 
                Render-ModelText -text $preText 
                
                # Speak the pre-text if TTS is enabled
                if ($script:ttsEnabled -and $global:GemmaTTS) {
                    try {
                        $global:GemmaTTS.SpeakAsyncCancelAll()
                        $speakPreText = Format-TextForSpeech -text $preText
                        if ($speakPreText) {
                            $global:GemmaTTS.SpeakAsync($speakPreText) | Out-Null
                        }
                    } catch {}
                }
            }
         # Bulletproof sanitization: handles escaped quotes AND escaped backslashes
         $jsonStr = $jsonStr -replace "\r\n", ' '
         $jsonStr = $jsonStr -replace "\r",   ' '
         $jsonStr = $jsonStr -replace "\n",   ' '
    
         if ($script:debugMode) {
            Write-Host "`n[DEBUG] Sanitized Tool Call JSON: $jsonStr" -ForegroundColor Yellow
         }
   
         try {
            $call = $jsonStr | ConvertFrom-Json
                $params = ConvertTo-Hashtable -Object $call.parameters
                $tool = $script:TOOLS[$call.name]
                if (-not $tool) {
                    throw "Unknown tool '$($call.name)' requested."
                }
                
                $label = Get-StandardToolLabel -Tool $tool -Params $params
                $isInteractive = $tool.Interactive -eq $true
                $securityIcon = if ($isInteractive) { "$WRN " } else { "" }

                $choice = Show-ArrowMenu `
                    -Options @("Allow once", "Deny") `
                    -Title "${securityIcon}Tool Request $ARR Action Required $BUL $label" `
                    -Width 110 `
                    -Default 0

                # Silence speech once a choice is made
                if ($global:GemmaTTS) { $global:GemmaTTS.SpeakAsyncCancelAll() }

                if ($choice -ne 0) {
                    Write-Host ""
                    Draw-Box @("$CRS  Tool call denied.") -Color Red
                    $script:history += @{ role = "model"; parts = @(@{ text = $modelText }) }
                    $script:history += @{ role = "user";  parts = @(@{ text = "[SYSTEM] TOOL RESULT: The user denied this tool call. Standing by for user correction/instruction." }) }
                    
                    # Force return to the user's turn
                    $script:toolJob = $null
                    $jsonStr = $null
                    break 
                }

                Write-Host ""
                if ($isInteractive) {
                    Draw-Box @("$WRN  $label (Interactive Mode - Main Thread)") -Color Yellow
                } else {
                    Draw-Box @("$CHK  $label") -Color Magenta
                }

                # Execute tool
                Stop-Spinner
                Start-Sleep -Milliseconds 160

                $result = $null
                $cancelled = $false

                if ($isInteractive) {
                    # Execute in the main process to maintain valid console handle for interactive input
                    try {
                        $toolFile = Join-Path $scriptDir "tools/$($call.name).ps1"
                        if (Test-Path $toolFile) {
                            $content = Get-Content -Path $toolFile -Raw -Encoding UTF8
                            Invoke-Expression $content
                        }
                        $result = & $tool.Execute $params
                    } catch {
                        $result = "ERROR: Exception while executing interactive tool '$($call.name)': $($_.Exception.Message)"
                    }
                } else {
                    Start-Spinner -Label "Executing $($call.name) (Esc to cancel)"
                    $script:toolJob = Start-Job -ScriptBlock {
                        param($toolName, $params, $toolsDir, $workDir, $scriptDir, $apiKey, $baseUri, $model, $toolLimits, $configDir, $history, $modelRegistry)
                        
                        # Ensure UTF8 output in background job to prevent Mojibake
                        [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
                        $OutputEncoding = [System.Text.Encoding]::UTF8

                        Set-Location -Path $workDir
                        
                        # Initialize core script state inside the job
                        $script:API_KEY = $apiKey
                        $script:BASE_URI_BASE = $baseUri
                        $script:MODEL = $model
                        $script:TOOL_LIMITS = $toolLimits
                        $script:MODEL_REGISTRY = $modelRegistry
                        $script:configDir = $configDir
                        $script:apiCallLog_Gemma = [System.Collections.Generic.List[datetime]]::new()
                        $script:apiCallLog_Gemini = [System.Collections.Generic.List[datetime]]::new()
                        $script:lastApiCall = (Get-Date).AddSeconds(-10)
                        $script:lastApiCall_Gemini = (Get-Date).AddSeconds(-10)
                        $script:history = $history

                        # Dot-source core libraries inside the job
                        . (Join-Path $scriptDir "lib/Api.ps1")
                        . (Join-Path $scriptDir "lib/History.ps1")
                        . (Join-Path $scriptDir "lib/UI.ps1")

                        $toolFile = Join-Path $toolsDir "$toolName.ps1"
                        if (-not (Test-Path $toolFile)) {
                            return "ERROR: Tool file '$toolFile' not found."
                        }
                        
                        try {
                            # Force reading the tool script as UTF8 to handle Unicode characters correctly
                            $toolContent = Get-Content -Path $toolFile -Raw -Encoding UTF8
                            Invoke-Expression -Command $toolContent

                            if (-not $ToolMeta.Execute) {
                                return "ERROR: Tool '$toolName' is missing its 'Execute' scriptblock."
                            }
                            # Invoke the tool's execution block with the parameters
                            return & $ToolMeta.Execute $params
                        } catch {
                            return "ERROR: Exception while executing tool '$toolName': $($_.Exception.Message) | StackTrace: $($_.ScriptStackTrace)"
                        } finally {
                            $ToolMeta = $null
                        }
                    } -ArgumentList $call.name, $params, (Join-Path $scriptDir "tools"), (Get-Location), $scriptDir, $script:API_KEY, $script:BASE_URI_BASE, $script:MODEL, $script:TOOL_LIMITS, $script:configDir, $script:history, $script:MODEL_REGISTRY

                    while ($script:toolJob.State -eq "Running") {
                        if ([Console]::KeyAvailable) {
                            $key = [Console]::ReadKey($true)
                            if ($key.Key -eq "Escape") {
                                $cancelled = $true
                                Stop-Job $script:toolJob
                                break
                            }
                        }
                        Start-Sleep -Milliseconds 100
                    }

                    if (-not $cancelled) {
                        $result = Receive-Job $script:toolJob
                    }
                    Remove-Job $script:toolJob -Force
                    Stop-Spinner
                }

                if ($cancelled) {
                    Write-Host " [Tool execution cancelled by user]" -ForegroundColor Yellow
                    break
                }

                if ($script:debugMode) { Write-Host "`n[DEBUG] Tool Execution Result: $result" -ForegroundColor Yellow }

                # Ensure result is a single clean string (job may return string[])
                if ($result -is [array]) { $result = $result -join "`n" }
                if (-not $result) { $result = "(empty result)" }

                # Strip control characters (null bytes, BOM, etc.) that break JSON
                $result = $result -replace '[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]', ''
                # Remove UTF-8 BOM if present
                $result = $result.TrimStart([char]0xFEFF)

                $maxChars = 20000
                $truncated = $false
                if ($result.Length -gt $maxChars) {
                  $result = $result.Substring(0, $maxChars)
                  $truncated = $true
                }
                $truncNote = if ($truncated) { "`n[Note: file was truncated to $maxChars characters due to size limits]" } else { "" }

                # Handle console-only messages (printed to user, stripped before Gemma sees result)
                if ($result -match "(?s)^CONSOLE::(.+?)::END_CONSOLE::(.*)$") {
                    $consoleRaw = $matches[1]
                    $result = $matches[2].Trim()

                    # Handle inline instructions like SET_VOICE
                    if ($consoleRaw -match "SET_VOICE:(David|Zira)") {
                        $voiceName = if ($matches[1] -eq "David") { "Microsoft David Desktop" } else { "Microsoft Zira Desktop" }
                        if ($global:GemmaTTS) {
                            try { $global:GemmaTTS.SelectVoice($voiceName) } catch {}
                        }
                        # Strip the instruction from the displayed console text
                        $consoleRaw = $consoleRaw -replace "::SET_VOICE:(David|Zira)", ""
                    }

                    # Handle inline instructions for BEEP
                    if ($consoleRaw -match "BEEP:([0-9,;]+)") {
                        $beepData = $matches[1]
                        foreach ($b in $beepData -split ";") {
                            $parts = $b -split ","
                            if ($parts.Count -eq 2) {
                                try { [console]::Beep([int]$parts[0], [int]$parts[1]) } catch {}
                            }
                        }
                        $consoleRaw = $consoleRaw -replace "::?BEEP:[0-9,;]+", ""
                    }

                    # Handle inline instructions for PLAY_SOUND (WAV files from C:\Windows\Media)
                    if ($consoleRaw -match "PLAY_SOUND:([\w\s.-]+)") {
                        $soundFile = $matches[1]
                        $fullPath = "C:\Windows\Media\$soundFile"
                        if (-not ($fullPath.EndsWith(".wav"))) { $fullPath += ".wav" }
                        
                        if (Test-Path $fullPath) {
                            $speaker = $null
                            try {
                                $speaker = New-Object System.Media.SoundPlayer
                                $speaker.SoundLocation = $fullPath
                                $speaker.Play() 
                            } catch {} finally {
                                if ($speaker) { $speaker.Dispose() }
                            }
                        }
                        $consoleRaw = $consoleRaw -replace "::?PLAY_SOUND:[\w\s.-]+", ""
                    }

                    $consoleText = Convert-ToHyperlink -Text $consoleRaw
                    Write-Host $consoleText -ForegroundColor DarkGray
                    if (-not $result) { $result = "(empty result)" }
                }

                # Handle image tool results — inject as multimodal content
                if ($result -match "^IMAGE_DATA::([^:]+)::([^:]+)::(.+)$") {
                    $mime   = $matches[1]
                    $b64    = $matches[2]
                    $prompt = $matches[3]
                    $script:history += @{ role = "model"; parts = @(@{ text = $modelText }) }
                    $script:history += @{
                        role  = "user"
                        parts = @(
                            @{ text = "[SYSTEM] TOOL RESULT: Image loaded. $prompt" },
                            @{ inline_data = @{ mime_type = $mime; data = $b64 } }
                        )
                    }
                } else {
                    $script:history += @{ role = "model"; parts = @(@{ text = $modelText }) }
                    $script:history += @{ role = "user"; parts = @(@{ text = "[SYSTEM] TOOL RESULT:`n$result$truncNote`n`nNow respond to the user based on context. Do not call this tool again immediately." }) }
                }

                Write-ApiLog -toolName $call.name
                continue

            } catch {
                Write-Host "Tool call parse error: $($_.Exception.Message)" -ForegroundColor Red
                break
            }

       } else {
            if ($script:debugMode) {
                Write-Host "`n[DEBUG] Raw Model Text: $modelText" -ForegroundColor Yellow
            }
            $script:history += @{ role = "model"; parts = @(@{ text = $modelText }) }
            Render-ModelText -text $modelText
            
            if ($script:ttsEnabled -and $global:GemmaTTS) {
                try {
                    $global:GemmaTTS.SpeakAsyncCancelAll()
                    $speakText = Format-TextForSpeech -text $modelText
                    if ($speakText) {
                        $global:GemmaTTS.SpeakAsync($speakText) | Out-Null
                    }
                } catch { }
            }
            break
        }
    }
    # Save session history for 'skillify' and '/resume' after each turn
    try {
        $script:history | ConvertTo-Json -Depth 20 | Set-Content -Path $script:historyFile -Encoding UTF8 -Force
    } catch { }
}

Write-Host ""
Draw-Box @("Goodbye!  Thanks for using Gemma CLI.") -Color $script:Colors.ui_boxes