codec.py

#!/usr/bin/env python3
import signal
signal.signal(signal.SIGINT, lambda *a: None)
signal.signal(signal.SIGTERM, lambda *a: None)
"""CODEC v2.1 | F13=on/off | F18=voice | F16=text | *=screenshot | +=doc | Wake word"""
import logging, threading, tempfile, subprocess, os, time, sqlite3, json, re, base64, shutil
from datetime import datetime
from pynput import keyboard

log = logging.getLogger(__name__)

# Audit emits route through the unified log_event adapter (real, not no-op)
# per docs/PHASE1-STEP1-DESIGN.md.
from codec_audit import log_event

# Ensure homebrew tools are on PATH (PM2 may not inherit full shell PATH)
_BREW = "/opt/homebrew/bin"
if _BREW not in os.environ.get("PATH", ""):
    os.environ["PATH"] = _BREW + ":" + os.environ.get("PATH", "")
SOX = shutil.which("sox") or "sox"

# ── CONFIG (single source of truth: codec_config.py) ─────────────────────────
from codec_config import (
    cfg as _cfg,
    QWEN_BASE_URL, QWEN_MODEL, LLM_API_KEY, LLM_KWARGS, QWEN_VISION_URL, QWEN_VISION_MODEL,
    WHISPER_URL,
    DB_PATH, TASK_QUEUE_FILE, DRAFT_TASK_FILE, SESSION_ALIVE, STREAMING, WAKE_WORD, WAKE_ENERGY, WAKE_CHUNK_SEC,
)

# Vision — prefer Gemini Flash (fast cloud), fall back to local Qwen VL
# These are codec.py-specific (not in codec_config)
GEMINI_API_KEY    = _cfg.get("gemini_api_key", os.environ.get("GEMINI_API_KEY", ""))
VISION_PROVIDER   = _cfg.get("vision_provider", "gemini" if GEMINI_API_KEY else "local")
DRAFT_KEYWORDS_CFG = _cfg.get("draft_keywords", [])

# ─��� SHARED (from codec_core.py — single source of truth) ─────────────────────
import codec_core as _core
from codec_core import (
    strip_think, is_draft, init_db, save_task, get_memory, get_recent_conversations,
    loaded_skills, load_skills, run_skill,
    transcribe, speak_text, focused_app, get_text_dialog,
    terminal_session_exists, close_session,
)
from codec_agent import run_session_in_terminal

from codec_overlays import show_overlay, show_recording_overlay, show_processing_overlay, show_toggle_overlay
from codec_identity import CODEC_VOICE_PROMPT

# ── SKILLS (codec.py-specific: ranked matching) ──────────────────────────────

def check_skills_ranked(task):
    """Return all matching skills, sorted by trigger length (best match first)."""
    low = task.lower()
    matches = []
    seen = set()
    for skill in loaded_skills:
        for trigger in skill['triggers']:
            if trigger in low and skill['name'] not in seen:
                matches.append((len(trigger), skill))
                seen.add(skill['name'])
    matches.sort(key=lambda x: x[0], reverse=True)
    return [s for _, s in matches]

def check_skill(task):
    ranked = check_skills_ranked(task)
    return ranked[0] if ranked else None

# ── VISION (Gemini Flash or local Qwen VL) ──────────────────────────────────
def _gemini_vision(img_b64, prompt, max_tokens=800):
    """Call Gemini Flash vision API. Fast, reliable, free tier."""
    import requests
    url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
    payload = {
        "contents": [{"parts": [
            {"inlineData": {"mimeType": "image/png", "data": img_b64}},
            {"text": prompt}
        ]}],
        "generationConfig": {"maxOutputTokens": max_tokens}
    }
    r = requests.post(url, json=payload, timeout=30)
    if r.status_code == 200:
        candidates = r.json().get("candidates", [])
        if candidates:
            parts = candidates[0].get("content", {}).get("parts", [])
            if parts:
                return parts[0].get("text", "").strip()
    else:
        print(f"[CODEC] Gemini error {r.status_code}: {r.text[:200]}")
    return ""

def _local_vision(img_b64, prompt, max_tokens=800):
    """Call local Qwen VL vision API (fallback)."""
    import requests
    r = requests.post(f"{QWEN_VISION_URL}/chat/completions",
        json={"model": QWEN_VISION_MODEL,
            "messages": [{"role": "user", "content": [
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img_b64}"}},
                {"type": "text", "text": prompt}
            ]}], "max_tokens": max_tokens}, timeout=60)
    if r.status_code == 200:
        return r.json()["choices"][0]["message"].get("content", "").strip()
    return ""

def vision_describe(img_b64, prompt="Read all visible text on this screen. Include app name, window title, and all message/content text. Output raw text only.", max_tokens=800):
    """Route vision to Gemini or local based on config."""
    if VISION_PROVIDER == "gemini" and GEMINI_API_KEY:
        result = _gemini_vision(img_b64, prompt, max_tokens)
        if result:
            return result
        print("[CODEC] Gemini failed, falling back to local vision...")
    return _local_vision(img_b64, prompt, max_tokens)

def screenshot_ctx():
    try:
        tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
        tmp.close()
        subprocess.run(["screencapture", "-x", tmp.name], timeout=5)
        if not os.path.exists(tmp.name) or os.path.getsize(tmp.name) < 1000:
            return ""
        with open(tmp.name, "rb") as f:
            img_b64 = base64.b64encode(f.read()).decode()
        os.unlink(tmp.name)
        provider = "Gemini Flash" if (VISION_PROVIDER == "gemini" and GEMINI_API_KEY) else "Qwen VL"
        print(f"[CODEC] Reading screen via {provider}...")
        content = vision_describe(img_b64)
        if content:
            print(f"[CODEC] Screen context: {len(content)} chars")
            return content[:2000]
    except Exception as e:
        print(f"[CODEC] Vision error: {e}")
    return ""

# ── STATE ─────────────────────────────────────────────────────────────────────
state = {
    "active": False,
    "recording": False,
    "rec_proc": None,
    "audio_path": None,
    "last_f13": 0.0,
    "last_star": 0.0,
    "screen_ctx": "",
    "screen_ctx_ts": 0.0,   # when screen_ctx was captured; used for TTL expiry
    "last_plus": 0.0,
    "last_minus": 0.0,
    "doc_ctx": "",
}

# ── SCREEN-CONTEXT RELEVANCE GATE ─────────────────────────────────────────────
# Tasks that clearly have nothing to do with the screen — skip context injection
# to prevent the LLM from being confused by stale/irrelevant captured text.
_TRIVIAL_SCREEN_BYPASS = re.compile(
    r"^\s*(?:"
    r"\d+\s*[+\-*/x×÷]\s*\d+"               # arithmetic: "1+1", "5 * 3"
    r"|what\s*time"                         # "what time is it"
    r"|time\s*(?:is\s*it|now)?"             # "time now"
    r"|what'?s?\s+the\s+date"               # "what's the date"
    r"|bitcoin\s*(?:price)?"                # "bitcoin price"
    r"|btc\s*price"
    r"|weather"                             # weather queries
    r"|calculate\s+"                        # "calculate 5 * 4"
    r"|speed\s*test"                        # the user's actual failing query
    r"|ping"
    r"|hello|hi|hey"                        # greetings
    r"|status|health|uptime"                # system checks
    r")\b",
    re.IGNORECASE,
)
_SCREEN_CTX_TTL = 120.0  # seconds — stale screen context expires

def _maybe_screen_context(task: str) -> str:
    """Return ' [SCREEN CONTEXT: ...]' to append, or '' if skipped.

    Clears expired/used screen_ctx as a side-effect. Keeps existing behavior
    when the task genuinely looks screen-related; skips for trivial lookups or
    when the captured screenshot is older than TTL.
    """
    ctx = state.get("screen_ctx", "")
    if not ctx:
        return ""
    # TTL: stale screenshots shouldn't follow the user around
    ts = state.get("screen_ctx_ts", 0.0)
    if ts and (time.time() - ts) > _SCREEN_CTX_TTL:
        print(f"[CODEC] Screen context expired ({int(time.time()-ts)}s old) — discarding")
        state["screen_ctx"] = ""
        state["screen_ctx_ts"] = 0.0
        return ""
    # Relevance: trivial intents ignore screen context
    if _TRIVIAL_SCREEN_BYPASS.match(task or ""):
        print(f"[CODEC] Trivial task — skipping screen context injection")
        return ""
    # Use it, one-shot
    out = " [SCREEN CONTEXT: " + ctx[:800] + "]"
    state["screen_ctx"] = ""
    state["screen_ctx_ts"] = 0.0
    return out

# ── DISPATCH LOCK — only one dispatch at a time, prevents feedback loops ──
_dispatch_lock = threading.Lock()
_dispatch_cooldown = 0.0  # timestamp: ignore wake words until this time
_last_tts_text = ""  # last TTS output — used to strip echo from mic recordings

# ── VOICE CONVERSATION SESSION (persistent across F18 presses) ──────────────
voice_session = {
    "messages": [],      # [{role, content}, ...] — full conversation history
    "started": None,     # ISO timestamp of session start
    "turn_count": 0,     # number of exchanges
}

def reset_voice_session():
    """Clear voice conversation history (called on F13 toggle)."""
    voice_session["messages"] = []
    voice_session["started"] = None
    voice_session["turn_count"] = 0
    print("[CODEC] Voice session reset")

# ── WORK QUEUE ────────────────────────────────────────────────────────────────
work_queue = []
work_lock = threading.Lock()

def push(fn, *args):
    with work_lock:
        work_queue.append((fn, args))

def worker():
    while True:
        item = None
        with work_lock:
            if work_queue:
                item = work_queue.pop(0)
        if item:
            fn, args = item
            try: fn(*args)
            except Exception as e:
                print(f"[CODEC] Error: {e}")
                import traceback; traceback.print_exc()
        else:
            time.sleep(0.05)

# ── BUILD SESSION SCRIPT ─────────────────────────────────────────────────────
def build_session_script(safe_sys, session_id):
    L = []
    L.append("import os, sys, requests, json, time, sqlite3, tempfile, subprocess, re, select, atexit, base64")
    L.append("from datetime import datetime")
    L.append("")
    L.append("QWEN_BASE_URL = " + repr(QWEN_BASE_URL))
    L.append("QWEN_MODEL = " + repr(QWEN_MODEL))
    L.append("QWEN_VISION_URL = " + repr(QWEN_VISION_URL))
    L.append("QWEN_VISION_MODEL = " + repr(QWEN_VISION_MODEL))
    L.append("TTS_VOICE = " + repr(TTS_VOICE))
    L.append("LLM_API_KEY = " + repr(LLM_API_KEY))
    L.append("LLM_KWARGS = " + repr(LLM_KWARGS))
    L.append("LLM_PROVIDER = " + repr(LLM_PROVIDER))
    L.append("TTS_ENGINE = " + repr(TTS_ENGINE))
    L.append("KOKORO_URL = " + repr(KOKORO_URL))
    L.append("KOKORO_MODEL = " + repr(KOKORO_MODEL))
    L.append("DB_PATH = os.path.expanduser(" + repr(DB_PATH) + ")")
    L.append("TASK_QUEUE = " + repr(TASK_QUEUE_FILE))
    L.append("SESSION_ALIVE = " + repr(SESSION_ALIVE))
    L.append("SYS_MSG = " + repr(safe_sys))
    L.append("STREAMING = " + repr(STREAMING))
    L.append("SESSION_ID = " + repr(session_id))
    L.append("")
    L.append("def cleanup():")
    L.append("    try: os.unlink(SESSION_ALIVE)")
    L.append("    except: pass")
    L.append("    print('[CODEC] Session closed.')")
    L.append("atexit.register(cleanup)")
    L.append("")
    L.append("SCREEN_KW = ['look at my screen','look at the screen',\"what's on my screen\",'whats on my screen','read my screen','see my screen','screen','what am i looking at','what do you see','look at this']")
    L.append("CORRECTION_WORDS = ['no i meant','not that','wrong','i meant','actually i want','thats not right','no no','no open','i said','please use']")
    L.append("")
    L.append("def needs_screen(t): return any(k in t.lower() for k in SCREEN_KW)")
    L.append("")
    L.append("AGENT_SYS = '''You are CODEC, an AI agent with FULL access to a Mac Studio M1 Ultra.")
    L.append("You can execute bash commands and AppleScript to accomplish any task.")
    L.append("RESPOND IN THIS EXACT JSON FORMAT:")
    L.append('{ "thought": "brief plan", "action": "bash" or "applescript" or "done", "code": "command to execute", "summary": "what you did (only when action is done)" }')
    L.append("RULES: For URLs use bash open command. For apps use applescript. When done action=done with summary.")
    L.append("Be concise. Max 8 steps. MULTI-STEP: execute each step, dont skip, dont say done until ALL complete. SAFETY: NEVER delete files or data without asking the user for confirmation first.")
    L.append("ALWAYS respond with valid JSON only.'''")
    L.append("")
    L.append("def strip_think(t): return re.sub(r'<think>.*?</think>', '', t, flags=re.DOTALL).strip()")
    L.append("")
    L.append("def extract_content(rj):")
    L.append("    msg = rj['choices'][0]['message']")
    L.append("    c = msg.get('content','').strip()")
    L.append("    if c: return strip_think(c)")
    L.append("    r = msg.get('reasoning','').strip()")
    L.append("    if r: return strip_think(r)")
    L.append("    return ''")
    L.append("")
    L.append("with open(SESSION_ALIVE, 'w') as _pf: _pf.write(str(os.getpid()))")
    L.append("")
    L.append("def screenshot_ctx():")
    L.append("    try:")
    L.append("        tmp = tempfile.NamedTemporaryFile(suffix='.png', delete=False); tmp.close()")
    L.append("        subprocess.run(['screencapture', '-x', tmp.name], timeout=5)")
    L.append("        if not os.path.exists(tmp.name) or os.path.getsize(tmp.name) < 1000: return ''")
    L.append("        with open(tmp.name, 'rb') as f: ib = base64.b64encode(f.read()).decode()")
    L.append("        os.unlink(tmp.name)")
    L.append("        print('[CODEC] Reading screen...')")
    L.append("        r = requests.post(QWEN_VISION_URL+'/chat/completions', json={'model':QWEN_VISION_MODEL,'messages':[{'role':'user','content':[{'type':'image_url','image_url':{'url':'data:image/png;base64,'+ib}},{'type':'text','text':'Read all visible text. Include app name and content. Raw text only.'}]}],'max_tokens':800}, timeout=60)")
    L.append("        if r.status_code == 200: return r.json()['choices'][0]['message'].get('content','')[:2000]")
    L.append("    except: pass")
    L.append("    return ''")
    L.append("")
    L.append("def speak(text):")
    L.append("    print('[TTS] Speaking: ' + text[:60])")
    L.append("    try:")
    L.append("        clean = re.sub(r'[*#`]', '', text[:300]).replace('\"','').replace(\"'\",'').strip()")
    L.append("        if not clean: return")
    L.append("        if TTS_ENGINE == 'disabled': return")
    L.append("        if TTS_ENGINE == 'macos_say':")
    L.append("            subprocess.Popen(['say', '-v', TTS_VOICE, clean])")
    L.append("            return")
    L.append("        r = requests.post(KOKORO_URL, json={'model':KOKORO_MODEL,'input':clean,'voice':TTS_VOICE}, stream=True, timeout=20)")
    L.append("        if r.status_code == 200:")
    L.append("            tmp = tempfile.NamedTemporaryFile(suffix='.mp3', delete=False)")
    L.append("            [tmp.write(c) for c in r.iter_content(4096)]; tmp.close()")
    L.append("            subprocess.Popen(['afplay', tmp.name])")
    L.append("    except: pass")
    L.append("")
    L.append("def qwen_call(messages):")
    L.append("    headers = {'Content-Type': 'application/json'}")
    L.append("    if LLM_API_KEY: headers['Authorization'] = 'Bearer ' + LLM_API_KEY")
    L.append("    payload = {'model':QWEN_MODEL,'messages':messages,'max_tokens':500,'temperature':0.5}")
    L.append("    payload.update(LLM_KWARGS)")
    L.append("    for _ in range(3):")
    L.append("        try:")
    L.append("            r = requests.post(QWEN_BASE_URL+'/chat/completions', json=payload, headers=headers, timeout=90)")
    L.append("            if r.status_code == 200:")
    L.append("                resp = extract_content(r.json())")
    L.append("                if resp: return resp")
    L.append("        except: time.sleep(2)")
    L.append("    return ''")
    L.append("")
    L.append("def qwen_stream(messages):")
    L.append("    try:")
    L.append("        headers = {'Content-Type': 'application/json'}")
    L.append("        if LLM_API_KEY: headers['Authorization'] = 'Bearer ' + LLM_API_KEY")
    L.append("        payload = {'model':QWEN_MODEL,'messages':messages,'max_tokens':500,'temperature':0.5,'stream':True}")
    L.append("        payload.update(LLM_KWARGS)")
    L.append("        r = requests.post(QWEN_BASE_URL+'/chat/completions', json=payload, headers=headers, timeout=90, stream=True)")
    L.append("        if r.status_code != 200: return qwen_call(messages)")
    L.append("        full = ''")
    L.append("        for line in r.iter_lines():")
    L.append("            if not line: continue")
    L.append("            line = line.decode('utf-8')")
    L.append("            if line.startswith('data: '):")
    L.append("                d = line[6:]")
    L.append("                if d.strip() == '[DONE]': break")
    L.append("                try:")
    L.append("                    delta = json.loads(d).get('choices',[{}])[0].get('delta',{}).get('content','')")
    L.append("                    if delta: sys.stdout.write(delta); sys.stdout.flush(); full += delta")
    L.append("                except: pass")
    L.append("        print()")
    L.append("        return strip_think(full).strip()")
    L.append("    except: return qwen_call(messages)")
    L.append("")
    L.append("def run_code(action, code):")
    L.append("    try:")
    L.append("        if action == 'applescript': r = subprocess.run(['osascript','-e',code], capture_output=True, text=True, timeout=30)")
    L.append("        else: r = subprocess.run(['bash','-c',code], capture_output=True, text=True, timeout=30)")
    L.append("        out = r.stdout.strip(); err = r.stderr.strip()")
    L.append("        return (out or err or 'OK (no output)')[:500]")
    L.append("    except subprocess.TimeoutExpired: return 'ERROR: Timeout'")
    L.append("    except Exception as e: return 'ERROR: '+str(e)")
    L.append("")
    L.append("def run_agent(task, h):")
    L.append("    print(chr(10)+'[Q-Agent] Task: '+task[:100])")
    L.append("    am = [{'role':'system','content':AGENT_SYS},{'role':'user','content':'Task: '+task}]")
    L.append("    for step in range(8):")
    L.append("        resp = qwen_call(am)")
    L.append("        if not resp: return 'Qwen did not respond.'")
    L.append("        try:")
    L.append("            c = resp")
    L.append("            if '```json' in c: c = c.split('```json')[1].split('```')[0]")
    L.append("            elif '```' in c: c = c.split('```')[1].split('```')[0]")
    L.append("            data = json.loads(c.strip())")
    L.append("        except:")
    L.append("            print('Q: '+resp); h.append({'role':'user','content':task}); h.append({'role':'assistant','content':resp}); return resp")
    L.append("        act = data.get('action','done'); thought = data.get('thought',''); code = data.get('code',''); summary = data.get('summary','')")
    L.append("        if thought: print('  [Think] '+thought)")
    L.append("        if act == 'done':")
    L.append("            result = summary or 'Task completed.'")
    L.append("            print('  [Done] '+result); h.append({'role':'user','content':task}); h.append({'role':'assistant','content':result}); return result")
    L.append("        if code:")
    L.append("            print('  ['+act+'] '+code[:80]); output = run_code(act, code); print('  [Result] '+output[:200])")
    L.append("            am.append({'role':'assistant','content':resp}); am.append({'role':'user','content':'Output: '+output+chr(10)+'Continue or done?'})")
    L.append("        else:")
    L.append("            am.append({'role':'assistant','content':resp}); am.append({'role':'user','content':'No code. Try again or done.'})")
    L.append("    return 'Task completed (max steps).'")
    L.append("")
    L.append("def ask_q(u, h):")
    L.append("    now = datetime.now().strftime('%Y-%m-%d %H:%M')")
    L.append("    if needs_screen(u):")
    L.append("        print('[CODEC] Taking screenshot...'); ctx = screenshot_ctx()")
    L.append("        if ctx: u = u + chr(10)+chr(10)+'SCREEN CONTENT:'+chr(10)+ctx")
    L.append("    h.append({'role':'user','content':'['+now+'] '+u})")
    L.append("    if STREAMING:")
    L.append("        sys.stdout.write(chr(10)+'Q: '); sys.stdout.flush(); resp = qwen_stream(h)")
    L.append("    else: resp = qwen_call(h)")
    L.append("    if resp:")
    L.append("        h.append({'role':'assistant','content':resp})")
    L.append("        if len(h) > 22: h[:] = h[:1] + h[-20:]")
    L.append("        return resp")
    L.append("    return 'Qwen busy.'")
    L.append("")
    L.append("def check_queue():")
    L.append("    if os.path.exists(TASK_QUEUE):")
    L.append("        try:")
    L.append("            with open(TASK_QUEUE) as f: data = json.load(f)")
    L.append("            os.unlink(TASK_QUEUE); return data")
    L.append("        except: pass")
    L.append("    return None")
    L.append("")
    L.append("def clean_resp(text):")
    L.append("    t = text.strip()")
    L.append("    for p in ['Done.','Done:','Done,','Done ']: ")
    L.append("        if t.startswith(p): t = t[len(p):].strip()")
    L.append("    if t.startswith('[') and t.endswith(']'): t = t[1:-1].strip()")
    L.append("    return t or text")
    L.append("")
    L.append("def detect_correction(u, h):")
    L.append("    low = u.lower()")
    L.append("    if any(c in low for c in CORRECTION_WORDS) and len(h) >= 2:")
    L.append("        lu = la = ''")
    L.append("        for msg in reversed(h):")
    L.append("            if msg['role']=='assistant' and not la: la = msg['content']")
    L.append("            elif msg['role']=='user' and not lu: lu = msg['content']")
    L.append("            if lu and la: break")
    L.append("        if lu:")
    L.append("            try:")
    L.append("                c = sqlite3.connect(DB_PATH)")
    L.append("                c.execute('CREATE TABLE IF NOT EXISTS corrections (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT, original TEXT, corrected TEXT, context TEXT)')")
    L.append("                c.execute('INSERT INTO corrections (timestamp,original,corrected,context) VALUES (?,?,?,?)', (datetime.now().isoformat(),lu[:200],u[:200],la[:200]))")
    L.append("                c.commit(); c.close(); print('[CODEC] Correction saved.')")
    L.append("            except: pass")
    L.append("")
    L.append("def get_corrections():")
    L.append("    try:")
    L.append("        c = sqlite3.connect(DB_PATH)")
    L.append("        c.execute('CREATE TABLE IF NOT EXISTS corrections (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT, original TEXT, corrected TEXT, context TEXT)')")
    L.append("        rows = c.execute('SELECT original,corrected FROM corrections ORDER BY id DESC LIMIT 5').fetchall(); c.close()")
    L.append("        if rows: return chr(10).join(['USER CORRECTIONS:']+['M said: '+o[:60]+' -> corrected: '+co[:60] for o,co in rows])")
    L.append("    except: pass")
    L.append("    return ''")
    L.append("")
    L.append("def process_input(u, h):")
    L.append("    print(chr(10)+'M: '+u)")
    L.append("    detect_correction(u, h)")
    L.append("    corr = get_corrections()")
    L.append("    if corr and h and h[0]['role']=='system' and 'CORRECTIONS' not in h[0]['content']:")
    L.append("        h[0]['content'] = h[0]['content']+chr(10)+chr(10)+corr")
    L.append("    action_words = ['create','open','delete','move','copy','search','find','run','install','download','check','list','show','make','build','fix','update','write','read','send','get','set','start','stop']")
    L.append("    if any(w in u.lower().split() for w in action_words):")
    L.append("        done = clean_resp(run_agent(u, h)); print(chr(10)+'Q: '+done); speak(done)")
    L.append("    else:")
    L.append("        resp = clean_resp(ask_q(u, h))")
    L.append("        if not STREAMING: print(chr(10)+'Q: '+resp)")
    L.append("        speak(resp)")
    L.append("")
    L.append("# Load persistent memory")
    L.append("prev = []")
    L.append("try:")
    L.append("    c = sqlite3.connect(DB_PATH)")
    L.append("    c.execute('CREATE TABLE IF NOT EXISTS conversations (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, timestamp TEXT, role TEXT, content TEXT)')")
    L.append("    rows = c.execute('SELECT role,content FROM conversations ORDER BY id DESC LIMIT 10').fetchall(); c.close()")
    L.append("    if rows: rows.reverse(); prev = [{'role':r,'content':ct} for r,ct in rows]; print('[CODEC] Loaded '+str(len(prev))+' messages from previous sessions.')")
    L.append("except: pass")
    L.append("")
    L.append("h = [{'role':'system','content':SYS_MSG}] + prev")
    L.append("ss = 'ON' if STREAMING else 'OFF'")
    L.append("O = chr(27)+'[38;2;232;113;26m'")
    L.append("D = chr(27)+'[38;2;80;80;80m'")
    L.append("W = chr(27)+'[38;2;200;200;200m'")
    L.append("R = chr(27)+'[0m'")
    L.append("print(O+'    ╔══════════════════════════════════════════════════╗')")
    L.append("print(O+'    ║                                                  ║')")
    L.append("print(O+'    ║    ██████  ██████  ██████  ███████  ██████        ║')")
    L.append("print(O+'    ║   ██      ██    ██ ██   ██ ██      ██            ║')")
    L.append("print(O+'    ║   ██      ██    ██ ██   ██ █████   ██            ║')")
    L.append("print(O+'    ║   ██      ██    ██ ██   ██ ██      ██            ║')")
    L.append("print(O+'    ║    ██████  ██████  ██████  ███████  ██████        ║')")
    L.append("print(O+'    ║                                          v1.0    ║')")
    L.append("print(O+'    ╠══════════════════════════════════════════════════╣')")
    L.append("print(O+'    ║'+W+'  F18 voice   F16 text   ** screen   ++ doc   '+O+'║')")
    L.append("print(O+'    ║'+W+'  Hey CODEC = wake word  type exit to close    '+O+'║')")
    L.append("print(O+'    ╠══════════════════════════════════════════════════╣')")
    L.append("print(O+'    ║'+D+'  Stream='+ss+'  Memory=ON  Skills=ON             '+O+'║')")
    L.append("print(O+'    ╚══════════════════════════════════════════════════╝'+R)")
    L.append("")
    L.append("queued = check_queue()")
    L.append("if queued: process_input(queued['task'], h)")
    L.append("")
    L.append("while True:")
    L.append("    queued = check_queue()")
    L.append("    if queued: process_input(queued['task'], h); continue")
    L.append("    sys.stdout.write(chr(10)+'M: '); sys.stdout.flush()")
    L.append("    while True:")
    L.append("        queued = check_queue()")
    L.append("        if queued: sys.stdout.write(chr(13)+' '*60+chr(13)); process_input(queued['task'], h); break")
    L.append("        try:")
    L.append("            ready,_,_ = select.select([sys.stdin],[],[],0.3)")
    L.append("            if ready:")
    L.append("                u = sys.stdin.readline().strip()")
    L.append("                u = re.sub(r'\\x1b\\[[0-9;]*[a-zA-Z~]','',u).strip()")
    L.append("                if not u: break")
    L.append("                if u.lower() in ['exit','quit','bye']: cleanup(); print(chr(10)+'[Q Session ended]'); sys.exit(0)")
    L.append("                process_input(u, h); break")
    L.append("        except (KeyboardInterrupt, EOFError): cleanup(); print(chr(10)+'[Q Session ended]'); sys.exit(0)")

    return "\n".join(L)

# ── SESSION CLEANUP ───────────────────────────────────────────────────────────
def close_session():
    if os.path.exists(SESSION_ALIVE):
        try:
            with open(SESSION_ALIVE) as f: pid = int(f.read().strip())
            os.kill(pid, 15)
            print(f"[CODEC] Session process {pid} terminated")
        except: pass
        try: os.unlink(SESSION_ALIVE)
        except: pass
    try: os.unlink(TASK_QUEUE_FILE)
    except: pass
    subprocess.Popen(["osascript", "-e",
        'tell application "Terminal" to close (every window whose name contains "python3.13 /var/folders")'],
        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

# ── DISPATCH ──────────────────────────────────────────────────────────────────
def dispatch(task):
    global _dispatch_cooldown
    if not _dispatch_lock.acquire(blocking=False):
        print(f"[CODEC] Dispatch BLOCKED (already processing): {task[:60]}")
        return
    try:
        _dispatch_inner(task)
    finally:
        # Post-dispatch cooldown — TTS is now blocking so audio is already done
        # 1.5s buffer for echo/reverb decay (was 5s — too long, made CODEC feel unresponsive)
        _dispatch_cooldown = time.time() + 1.5
        _dispatch_lock.release()

def _dispatch_inner(task):
    app = focused_app()
    log_event("wake_dispatch", "open-codec",
              f"Voice dispatch: {task[:80]}",
              extra={"task_preview": task[:200]})
    print(f"[CODEC] Task: {task[:80]} | App: {app}")
    _safe_task = task[:50].replace('\\', '\\\\').replace('"', '\\"')
    subprocess.Popen(["osascript", "-e", f'display notification "Heard: {_safe_task}" with title "CODEC"'],
        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

    # Check skills — try ranked matches, fall through if skill returns None
    skill_result = None
    if len(task) < 500:
        for skill in check_skills_ranked(task):
            result = run_skill(skill, task, app)
            if result is not None:
                push(lambda: show_overlay('Skill: ' + skill['name'], '#E8711A', 2000))
                global _last_tts_text
                _last_tts_text = str(result)[:200]
                speak_text(result)
                subprocess.Popen(["osascript", "-e", f'display notification "{str(result)[:80]}" with title "CODEC Skill"'],
                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                print(f"[CODEC] Skill response: {str(result)[:100]}")
                skill_result = str(result)
                # Add skill exchange to voice session for continuity
                voice_session["messages"].append({"role": "user", "content": task})
                voice_session["messages"].append({"role": "assistant", "content": f"[Skill: {skill['name']}] {skill_result}"})
                voice_session["turn_count"] += 1
                # Save to shared memory
                try:
                    from codec_memory import CodecMemory
                    cm = CodecMemory()
                    cm.save("voice", "user", task)
                    cm.save("voice", "assistant", skill_result[:500])
                except Exception as e:
                    log.warning(f"[CODEC] Memory save failed after skill: {e}")
                # After skill fires, grab screen context in background (don't block queue)
                def _post_skill_screenshot():
                    try:
                        time.sleep(2)
                        screen = screenshot_ctx()
                        if screen and len(screen) > 50:
                            voice_session["messages"].append({
                                "role": "user",
                                "content": f"[CONTEXT: My screen now shows: {screen[:1000]}]"
                            })
                            print(f"[CODEC] Post-skill screen captured: {len(screen)} chars")
                    except Exception as e:
                        print(f"[CODEC] Post-skill screenshot failed: {e}")
                threading.Thread(target=_post_skill_screenshot, daemon=True).start()
                return
            print(f"[CODEC] Skill {skill['name']} returned None, trying next...")

    if is_draft(task):
        push(lambda: show_overlay('Reading screen...', '#E8711A', 2000))
        ctx = screenshot_ctx()
        push(lambda: show_processing_overlay('Drafting your message...', 15000))
        with open(DRAFT_TASK_FILE, "w") as f:
            json.dump({"task": task, "ctx": ctx, "app": app}, f)
        print(f"[CODEC] Draft queued for watcher")
        return

    rid = save_task(task, app)

    # ── Build system prompt with memory ─────────────────────────────────
    mem = get_memory(5)
    mem_ctx = ""
    boot_ctx = ""
    facts_ctx = ""
    try:
        from codec_memory import CodecMemory
        cm = CodecMemory()
        targeted = cm.get_context(task, n=5)
        if targeted:
            mem_ctx += f"\n\n[MEMORY — RELEVANT PAST CONVERSATIONS]\n{targeted}\n[END MEMORY]"
        recent = cm.search_recent(days=3, limit=5)
        if recent:
            lines = ["[RECENT MEMORY — LAST 3 DAYS]"]
            for r in recent:
                ts = r["timestamp"][:16].replace("T", " ")
                snippet = r["content"][:200].replace("\n", " ")
                lines.append(f"  [{ts}] {r['role'].upper()}: {snippet}")
            lines.append("[END RECENT MEMORY]")
            mem_ctx += "\n\n" + "\n".join(lines)
    except Exception as e:
        log.warning("Memory context retrieval failed: %s", e)

    # ── Memory upgrade: L0/L1 identity + active temporal facts ──────────
    try:
        from codec_memory_upgrade import load_identity, query_valid_facts, compress_rule_based
        identity = load_identity()
        if identity:
            boot_ctx = f"\n\n[IDENTITY — BOOT PAYLOAD]\n{identity}\n[END IDENTITY]"
        facts = query_valid_facts(limit=20)
        if facts:
            lines = ["[ACTIVE FACTS]"]
            for f in facts:
                lines.append(f"  {f['key']} = {f['value']}")
            lines.append("[END FACTS]")
            facts_ctx = "\n\n" + "\n".join(lines)
        # Compress the recalled memory block to save tokens (identity+facts stay verbatim)
        if mem_ctx:
            mem_ctx = compress_rule_based(mem_ctx)
    except Exception as e:
        log.warning("Memory upgrade injection failed: %s", e)

    # 2026-04-29 prompt rewrite: CODEC_VOICE_PROMPT now contains a {date}
    # placeholder. Format it before use so the LLM doesn't see literal '{date}'.
    sys_p = CODEC_VOICE_PROMPT.format(date=datetime.now().strftime("%A, %B %d, %Y"))
    if boot_ctx: sys_p += boot_ctx
    if facts_ctx: sys_p += facts_ctx
    if mem: sys_p += "\n\n" + mem
    if mem_ctx: sys_p += mem_ctx
    safe_sys = sys_p.replace('\n', ' ')

    # ── Open terminal session (the real CODEC session window) ───────────
    with open(TASK_QUEUE_FILE, "w") as f:
        json.dump({"task": task, "app": app, "ts": datetime.now().isoformat()}, f)

    if terminal_session_exists():
        # Warm session: codec_session.py handles the LLM + TTS.
        # Skip the inline quick-reply to avoid double-TTS (bug fix 2026-04-16).
        print("[CODEC] Queued to existing session (inline quick-reply skipped)")
        return
    else:
        session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
        run_session_in_terminal(safe_sys, session_id, task)

    # ── Quick voice reply (immediate feedback while terminal loads) ─────
    # Only runs on COLD START — a warm terminal session handles TTS itself.
    if not voice_session["started"]:
        voice_session["started"] = datetime.now().isoformat()

    # Add current user message to session
    voice_session["messages"].append({"role": "user", "content": task})

    # Build LLM messages: system + conversation history (keep last 20 turns)
    llm_messages = [{"role": "system", "content": sys_p}]
    # Trim to last 10 messages to keep prompt fast on 35B model
    # Filter out system messages from history — Qwen requires system only at start
    history = [m for m in voice_session["messages"][-10:] if m["role"] != "system"]
    llm_messages.extend(history)

    push(lambda: show_processing_overlay('Thinking...', 15000))
    try:
        import requests as _llm_req
        headers = {}
        if LLM_API_KEY:
            headers["Authorization"] = f"Bearer {LLM_API_KEY}"
        payload = {
            "model": QWEN_MODEL,
            "messages": llm_messages,
            "max_tokens": 400,
            "temperature": 0.7,
            "chat_template_kwargs": {"enable_thinking": False},
        }
        payload.update(LLM_KWARGS)
        r = _llm_req.post(f"{QWEN_BASE_URL}/chat/completions", json=payload, headers=headers, timeout=120)
        if r.status_code == 200:
            data = r.json()
            answer = data.get("choices", [{}])[0].get("message", {}).get("content", "")
            answer = strip_think(answer).strip()
            if answer:
                print(f"[CODEC] Voice reply (turn {voice_session['turn_count']+1}): {answer[:120]}")
                log_event("tts_speak", "open-codec",
                          f"TTS: {answer[:60]}",
                          extra={"text_len": len(answer)})
                # Add assistant response to session history
                voice_session["messages"].append({"role": "assistant", "content": answer})
                voice_session["turn_count"] += 1
                # Save response to DB
                try:
                    c = sqlite3.connect(DB_PATH)
                    c.execute("UPDATE sessions SET response=? WHERE id=?", (answer[:500], rid))
                    c.commit(); c.close()
                except Exception as e:
                    log.warning(f"[CODEC] DB save failed: {e}")
                # Save to shared memory (same store as Chat)
                try:
                    cm = CodecMemory()
                    cm.save("voice", "user", task)
                    cm.save("voice", "assistant", answer)
                except Exception as e:
                    log.warning(f"[CODEC] Memory save failed after LLM: {e}")
                _last_tts_text = answer[:200]
                speak_text(answer)
                _safe_ans = answer[:80].replace('\\', '\\\\').replace('"', '\\"')
                subprocess.Popen(["osascript", "-e",
                    f'display notification "{_safe_ans}" with title "CODEC"'],
                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            else:
                print("[CODEC] Voice LLM returned empty response")
                speak_text("Sorry, I didn't get a response.")
        else:
            print(f"[CODEC] Voice LLM error: {r.status_code} {r.text[:200]}")
            speak_text("Sorry, the language model is not responding.")
    except Exception as e:
        log.error("Voice LLM call failed: %s", e)
        import traceback; traceback.print_exc()
        speak_text("Sorry, something went wrong.")

# ── DOCUMENT INPUT ────────────────────────────────────────────────────────────
def do_document_input():
    push(lambda: show_overlay('Select document...', '#E8711A', 3000))
    try:
        r = subprocess.run(["osascript", "-e",
            'set f to POSIX path of (choose file with prompt "Select a document for CODEC:" of type {"public.item"})'],
            capture_output=True, text=True, timeout=60)
        filepath = r.stdout.strip()
        if not filepath:
            print("[CODEC] No file selected"); return
        print(f"[CODEC] Document: {filepath}")
        push(lambda: show_overlay('Reading document...', '#E8711A', 3000))
        ext = os.path.splitext(filepath)[1].lower()
        fname = os.path.basename(filepath)
        content_text = ""

        if ext in ['.txt','.md','.csv','.json','.py','.js','.html','.css','.log']:
            with open(filepath, 'r', errors='ignore') as f:
                content_text = f.read()[:5000]
        elif ext in ['.png','.jpg','.jpeg','.gif','.webp']:
            try:
                with open(filepath, "rb") as imgf:
                    img_b64 = base64.b64encode(imgf.read()).decode()
                content_text = vision_describe(img_b64, "Describe this image in detail. Read any text visible.", 1000)[:5000]
            except Exception as e:
                print(f"[CODEC] Image vision error: {e}")
        elif ext == '.pdf':
            try:
                import fitz
                doc = fitz.open(filepath)
                content_text = "\n".join(p.get_text() for p in doc[:5])[:5000]
                doc.close()
                print(f"[CODEC] PDF extracted: {len(content_text)} chars from {len(doc)} pages")
            except Exception as e:
                print(f"[CODEC] PDF extraction error: {e}")

        if content_text:
            # Dispatch directly to terminal for analysis
            task = "Analyze and summarize this document (" + fname + "): " + content_text[:3000]
            print(f"[CODEC] Document dispatched ({len(content_text)} chars)")
            dispatch(task)
        else:
            push(lambda: show_overlay('Could not read document', '#ff3333', 2000))
    except Exception as e:
        print(f"[CODEC] Document error: {e}")

# ── SCREENSHOT SHORTCUT ──────────────────────────────────────────────────────
def do_screenshot_question():
    push(lambda: show_overlay('Analyzing screen...', '#E8711A', 3000))
    ctx = screenshot_ctx()
    if not ctx:
        push(lambda: show_overlay('Screenshot failed', '#ff3333', 2000))
        return
    print(f"[CODEC] Screenshot captured ({len(ctx)} chars)")
    # Show brief summary of what was captured, then open question dialog
    summary = ctx[:120].replace('"', '\\"').replace('\n', ' ')
    try:
        r = subprocess.run(["osascript", "-e",
            f'tell application "System Events"\nset frontmost of first process whose frontmost is true to true\nend tell\n'
            f'set t to text returned of (display dialog '
            f'"I captured your screen:\\n\\n{summary}…\\n\\nWhat would you like to know about it?" '
            f'default answer "" with title "CODEC Screenshot" '
            f'buttons {{"Cancel","Ask"}} default button "Ask")'],
            capture_output=True, text=True, timeout=120)
        question = r.stdout.strip()
        if question:
            task = question + " [SCREEN CONTEXT: " + ctx[:800] + "]"
            dispatch(task)
        else:
            # User cancelled — save for later F18/F16 AND inject into voice session
            state["screen_ctx"] = ctx
            voice_session["messages"].append({
                "role": "system",
                "content": f"[SCREEN CAPTURE: The user's screen currently shows: {ctx[:1000]}]"
            })
            state["screen_ctx_ts"] = time.time()
            push(lambda: show_overlay('Screenshot saved — use voice or text to ask', '#E8711A', 3000))
    except Exception as e:
        print(f"[CODEC] Screenshot dialog error: {e}")
        state["screen_ctx"] = ctx
        state["screen_ctx_ts"] = time.time()

# ── TEXT/VOICE HANDLERS ───────────────────────────────────────────────────────
def do_text():
    task = get_text_dialog()
    if task:
        task = task + _maybe_screen_context(task)
        dispatch(task)

def do_start_recording():
    tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
    state["audio_path"] = tmp.name; tmp.close()
    rec = subprocess.Popen(
        [SOX, "-t", "coreaudio", "default", "-r", "16000", "-c", "1", "-b", "16", "-e", "signed-integer", state["audio_path"]],
        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    state["rec_proc"] = rec
    print("[CODEC] Recording...")

def do_stop_voice():
    audio = state.get("audio_path")
    rec = state.get("rec_proc")
    rec_start = state.get("rec_start", 0)
    if rec:
        try: rec.terminate(); rec.wait(timeout=3)
        except Exception as e: log.debug("Recording process cleanup failed: %s", e)
    state["rec_proc"] = None; state["recording"] = False
    ovl = state.get("overlay_proc")
    if ovl:
        try: ovl.terminate()
        except Exception as e: log.debug("Overlay process cleanup failed: %s", e)
        state["overlay_proc"] = None
    if not audio or not os.path.exists(audio): return
    # Reject recordings shorter than 0.5s — just button taps, not speech
    rec_duration = time.time() - rec_start if rec_start else 0
    if rec_duration < 0.5:
        print(f"[CODEC] Recording too short ({rec_duration:.1f}s) — ignored")
        try: os.unlink(audio)
        except: pass
        return
    if os.path.getsize(audio) < 1000:
        try: os.unlink(audio)
        except Exception as e: log.debug("Audio file cleanup failed: %s", e)
        return
    print("[CODEC] Transcribing...")
    push(lambda: show_processing_overlay('Transcribing...', 2000))
    task = transcribe(audio)
    if not task: print("[CODEC] No speech detected"); return
    # Strip TTS echo — mic sometimes captures CODEC's own voice response
    if _last_tts_text and len(_last_tts_text) > 10:
        # Build fuzzy fragments from last TTS to match in transcription
        tts_lower = _last_tts_text.lower()
        task_lower = task.lower()
        # Find the longest overlap between end of task and TTS text
        for frag_len in range(min(len(tts_lower), len(task_lower)), 10, -1):
            frag = tts_lower[:frag_len]
            idx = task_lower.find(frag)
            if idx >= 0:
                # Everything from this match onward is likely TTS echo
                cleaned = task[:idx].strip()
                if len(cleaned) > 5:
                    print(f"[CODEC] Stripped TTS echo: '{task[idx:idx+60]}...'")
                    task = cleaned
                break
    print(f"[CODEC] Heard: {task}")
    task = task + _maybe_screen_context(task)
    dispatch(task)

# ── WAKE WORD LISTENER ───────────────────────────────────────────────────────
def wake_word_listener():
    import requests as req_wake
    sample_rate = 16000
    chunk_sec = WAKE_CHUNK_SEC
    # Find the Anker webcam mic — always use it for wake word regardless of BT devices
    wake_device = "default"
    try:
        import sounddevice as sd
        for i, d in enumerate(sd.query_devices()):
            if d['max_input_channels'] > 0 and 'anker' in d['name'].lower():
                wake_device = d['name']
                break
    except Exception as e: log.debug("Wake mic device detection failed: %s", e)
    print(f"[CODEC] Wake word listener started (mic: {wake_device}, threshold={WAKE_ENERGY}). Say 'Hey CODEC' to activate.")
    if WAKE_ENERGY > 1000:
        print(f"[CODEC] ⚠️  Wake energy threshold ({WAKE_ENERGY}) is very high — wake word may not trigger. Default is 200.")
    _wake_diag_done = False
    _wake_low_count = 0  # track consecutive below-threshold to warn user
    while True:
        if not WAKE_WORD or state["recording"]:
            time.sleep(0.3); continue
        # Skip while TTS is actively playing (prevents mic hearing our own voice)
        if _core.tts_playing:
            time.sleep(0.3); continue
        # Skip for 8s after TTS finishes (audio echo / reverb decay)
        if _core.tts_finished_at and (time.time() - _core.tts_finished_at) < 8.0:
            time.sleep(0.3); continue
        # Skip wake processing during dispatch cooldown (prevents hearing our own TTS)
        if time.time() < _dispatch_cooldown:
            time.sleep(0.3); continue
        # Skip if a dispatch is already in progress
        if _dispatch_lock.locked():
            time.sleep(0.3); continue
        try:
            tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False); tmp.close()
            subprocess.run(
                [SOX, "-t", "coreaudio", wake_device, "-r", str(sample_rate), "-c", "1",
                 "-b", "16", "-e", "signed-integer", tmp.name, "trim", "0", str(chunk_sec)],
                timeout=int(chunk_sec) + 3, capture_output=True)
            if not os.path.exists(tmp.name) or os.path.getsize(tmp.name) < 500:
                try: os.unlink(tmp.name)
                except Exception as e: log.debug("Wake temp file cleanup failed: %s", e)
                continue
            # Check actual audio energy
            try:
                import wave, numpy as np
                wf = wave.open(tmp.name, 'rb')
                data = np.frombuffer(wf.readframes(wf.getnframes()), dtype=np.int16)
                wf.close()
                energy = np.abs(data).mean()
            except Exception as e:
                log.debug("Wake audio energy check failed: %s", e)
                energy = 0
            if not _wake_diag_done or energy > 80:
                print(f"[CODEC] Wake mic: energy={energy:.0f} (threshold={WAKE_ENERGY})")
                _wake_diag_done = True
            if energy < WAKE_ENERGY:
                if energy > WAKE_ENERGY * 0.3:
                    _wake_low_count += 1
                    if _wake_low_count == 20:
                        print(f"[CODEC] ⚠️  Mic picks up speech (energy ~{energy:.0f}) but threshold is {WAKE_ENERGY}. Lower wake_energy in ~/.codec/config.json if wake word doesn't trigger.")
                try: os.unlink(tmp.name)
                except Exception as e: log.debug("Wake temp file cleanup failed: %s", e)
                continue
            try:
                with open(tmp.name, "rb") as f:
                    r = req_wake.post(WHISPER_URL,
                        files={"file": ("wake.wav", f, "audio/wav")},
                        data={"model": "mlx-community/whisper-large-v3-turbo", "language": "en"},
                        timeout=10)
                if r.status_code == 200:
                    text = r.json().get("text", "").lower().strip()
                    if not text or len(text) < 2:
                        continue
                    # Filter Whisper hallucinations (repetitive gibberish)
                    if len(text) > 120:
                        continue
                    print(f"[CODEC] Wake heard: '{text}'")
                    # Simple keyword match — if "codec/codex/kodak/kodec" appears anywhere, it's a wake
                    _WAKE_KEYWORDS = ["codec", "codex", "kodak", "kodec", "kodak", "co-dec", "caudec", "codag"]
                    _matched = any(kw in text for kw in _WAKE_KEYWORDS)
                    if _matched:
                        log_event("wake_word_detected", "open-codec",
                                  "Wake word detected")
                        # Auto-activate if not already on
                        if not state["active"]:
                            state["active"] = True
                            push(lambda: show_toggle_overlay(True, "F18=voice | **=screen | --=chat"))
                        command = text
                        # Strip wake keywords and common prefixes (case-insensitive)
                        for kw in _WAKE_KEYWORDS + ["hey", "and", "hay", "eh", "ay"]:
                            command = re.sub(r'(?i)\b' + re.escape(kw) + r'\b', '', command).strip()
                        command = re.sub(r'^[\s,.\-]+|[\s,.\-]+$', '', command)
                        if len(command) > 3:
                            print(f"[CODEC] Wake + command: {command}")
                            push(lambda: show_overlay('Heard you!', '#E8711A', 1500))
                            push(lambda cmd=command: dispatch(cmd))
                        else:
                            print("[CODEC] Wake word detected! Listening...")
                            push(lambda: show_overlay('Listening...', '#E8711A', 5000))
                            # Record follow-up command (8 seconds)
                            tmp2 = tempfile.NamedTemporaryFile(suffix=".wav", delete=False); tmp2.close()
                            subprocess.run(
                                [SOX, "-t", "coreaudio", wake_device, "-r", str(sample_rate), "-c", "1",
                                 "-b", "16", "-e", "signed-integer", tmp2.name, "trim", "0", "8"],
                                timeout=12, capture_output=True)
                            task = transcribe(tmp2.name)
                            if task:
                                print(f"[CODEC] Heard: {task}")
                                push(lambda t=task: dispatch(t))
            except Exception as e:
                print(f"[CODEC] Wake whisper error: {e}")
            finally:
                try: os.unlink(tmp.name)
                except Exception as e: log.debug("Wake temp file cleanup failed: %s", e)
        except Exception as e:
            print(f"[CODEC] Wake listener error: {e}")
            time.sleep(0.5)
        time.sleep(0.1)

# ── KEYBOARD ──────────────────────────────────────────────────────────────────
def on_press(key):
    now = time.time()
    if key == keyboard.Key.f13:
        if now - state["last_f13"] < 1.5: return
        state["last_f13"] = now
        if state["active"]:
            state["active"] = False
            push(lambda: show_toggle_overlay(False))
            push(close_session)
            reset_voice_session()
            print("[CODEC] OFF")
        else:
            state["active"] = True
            reset_voice_session()
            push(lambda: show_toggle_overlay(True, "F18=voice  F16=text  **=screen  ++=doc  --=chat"))
            print("[CODEC] ON -- F18=voice | F16=text | *=screen | +=doc | --=chat")
        return
    if not state["active"]: return
    if key == keyboard.Key.f16:
        if not state["recording"]:
            # Run text dialog in its own thread so it opens instantly
            # (don't wait for work_queue which may be blocked by vision/LLM)
            threading.Thread(target=do_text, daemon=True).start()
        return
    if key == keyboard.Key.f18:
        if not state["recording"]:
            # Don't start recording while TTS is speaking — mic captures speaker output
            if _core.tts_playing:
                print("[CODEC] F18 ignored — TTS still playing")
                return
            # Don't start if dispatch is still processing (cooldown)
            if time.time() < _dispatch_cooldown:
                print("[CODEC] F18 ignored — still processing")
                return
            state["recording"] = True
            state["rec_start"] = time.time()
            threading.Thread(target=lambda: subprocess.run(
                ['afplay', '/System/Library/Sounds/Glass.aiff'],
                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL), daemon=True).start()
            push(do_start_recording)
            state["overlay_proc"] = show_recording_overlay('F18')
        return
    if hasattr(key, 'char') and key.char == '*':
        if now - state["last_star"] < 0.25 and now - state.get("last_screenshot_time", 0) > 8:
            print("[CODEC] Star x2 -- screenshot mode")
            push(do_screenshot_question)
            state["last_star"] = 0.0
            state["last_screenshot_time"] = now
            return
        state["last_star"] = now
        return
    if hasattr(key, 'char') and key.char == '+':
        if now - state.get("last_plus", 0.0) < 0.5:
            print("[CODEC] Plus x2 -- document mode")
            push(do_document_input)
            state["last_plus"] = 0.0
            return
        state["last_plus"] = now
        return
    if hasattr(key, 'char') and key.char == '-':
        if now - state.get("last_minus", 0.0) < 0.5:
            print("[CODEC] Minus x2 -- live chat mode")
            voice_url = _cfg.get("voice_url", "http://localhost:8090/voice?auto=1")
            push(lambda: show_overlay('Live Chat connecting...', '#E8711A', 3000))
            subprocess.Popen(["open", "-a", "Google Chrome", voice_url])
            state["last_minus"] = 0.0
            return
        state["last_minus"] = now
        return

def on_release(key):
    if key == keyboard.Key.f18 and state["recording"]:
        # Kill overlay immediately on release (don't wait for work queue)
        ovl = state.get("overlay_proc")
        if ovl:
            try: ovl.terminate()
            except: pass
            state["overlay_proc"] = None
        threading.Thread(target=lambda: subprocess.run(
            ['afplay', '/System/Library/Sounds/Pop.aiff'],
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL), daemon=True).start()
        push(do_stop_voice)

# ── MAIN ──────────────────────────────────────────────────────────────────────
def main():
    from codec_logging import setup_logging
    setup_logging()
    init_db()
    for f in [SESSION_ALIVE, TASK_QUEUE_FILE, DRAFT_TASK_FILE]:
        try: os.unlink(f)
        except Exception as e: log.debug("Startup file cleanup failed (%s): %s", f, e)

    stream_label = "ON" if STREAMING else "OFF"
    wake_label = "ON" if WAKE_WORD else "OFF"
    O = "\033[38;2;232;113;26m"
    D = "\033[38;2;80;80;80m"
    W = "\033[38;2;200;200;200m"
    R = "\033[0m"
    print(f"""
{O}    ╔═══════════════════════════════════════════╗
    ║                                           ║
    ║  ██████  ██████  ██████  ███████  ██████  ║
    ║ ██      ██    ██ ██   ██ ██      ██       ║
    ║ ██      ██    ██ ██   ██ █████   ██       ║
    ║ ██      ██    ██ ██   ██ ██      ██       ║
    ║  ██████  ██████  ██████  ███████  ██████  ║
    ║                                   v2.1.0  ║
    ╠═══════════════════════════════════════════╣
    ║{W}  F13 toggle   F18 voice   ** screen       {O}║
    ║{W}  F16 text     ++ doc     -- chat          {O}║
    ║{W}  Hey CODEC = wake word (hands-free)           {O}║
    ╠═══════════════════════════════════════════╣
    ║{D}  Stream={stream_label}  Wake={wake_label}  Skills=ON            {O}║
    ╚═══════════════════════════════════════════╝{R}""")

    load_skills()
    print("[CODEC] Whisper: HTTP (port 8084)")
    print("[CODEC] Vision: Qwen VL (port 8082)")
    mem = get_memory(3)
    if mem: print(f"[CODEC] Memory: {mem.count(chr(10))+1} sessions loaded")
    convs = get_recent_conversations(10)
    if convs: print(f"[CODEC] Persistent memory: {len(convs)} messages from past sessions")
    if WAKE_WORD: print("[CODEC] Wake word: ON")
    print("[CODEC] Online. Press F13 to activate.")

    threading.Thread(target=worker, daemon=True).start()
    if WAKE_WORD:
        threading.Thread(target=wake_word_listener, daemon=True).start()

    while True:
        try:
            with keyboard.Listener(on_press=on_press, on_release=on_release) as l:
                l.join()
        except Exception as e:
            print(f"[CODEC] Listener restarting: {e}")
            time.sleep(0.5)

if __name__ == "__main__":
    main()