#!/usr/bin/env python3
"""BTerminal — Terminal SSH z panelem sesji, w stylu MobaXterm."""

import gi
gi.require_version("Gtk", "3.0")
gi.require_version("Vte", "2.91")
gi.require_version("Gdk", "3.0")

import json
import os
import subprocess
import tempfile
import uuid

from gi.repository import Gdk, Gio, GLib, Gtk, Pango, Vte

# ─── Stałe i konfiguracja ────────────────────────────────────────────────────

APP_NAME = "BTerminal"
CONFIG_DIR = os.path.expanduser("~/.config/bterminal")
SESSIONS_FILE = os.path.join(CONFIG_DIR, "sessions.json")
CLAUDE_SESSIONS_FILE = os.path.join(CONFIG_DIR, "claude_sessions.json")
SSH_PATH = "/usr/bin/ssh"

def _find_claude_path():
    for p in [
        os.path.expanduser("~/.local/bin/claude"),
        "/usr/local/bin/claude",
        "/usr/bin/claude",
    ]:
        if os.path.isfile(p) and os.access(p, os.X_OK):
            return p
    import shutil
    return shutil.which("claude") or "claude"

CLAUDE_PATH = _find_claude_path()

FONT = "Monospace 11"
SCROLLBACK_LINES = 10000

# Catppuccin Mocha
CATPPUCCIN = {
    "rosewater": "#f5e0dc",
    "flamingo":  "#f2cdcd",
    "pink":      "#f5c2e7",
    "mauve":     "#cba6f7",
    "red":       "#f38ba8",
    "maroon":    "#eba0ac",
    "peach":     "#fab387",
    "yellow":    "#f9e2af",
    "green":     "#a6e3a1",
    "teal":      "#94e2d5",
    "sky":       "#89dceb",
    "sapphire":  "#74c7ec",
    "blue":      "#89b4fa",
    "lavender":  "#b4befe",
    "text":      "#cdd6f4",
    "subtext1":  "#bac2de",
    "subtext0":  "#a6adc8",
    "overlay2":  "#9399b2",
    "overlay1":  "#7f849c",
    "overlay0":  "#6c7086",
    "surface2":  "#585b70",
    "surface1":  "#45475a",
    "surface0":  "#313244",
    "base":      "#1e1e2e",
    "mantle":    "#181825",
    "crust":     "#11111b",
}

TERMINAL_PALETTE = [
    "#45475a", "#f38ba8", "#a6e3a1", "#f9e2af",
    "#89b4fa", "#f5c2e7", "#94e2d5", "#bac2de",
    "#585b70", "#f38ba8", "#a6e3a1", "#f9e2af",
    "#89b4fa", "#f5c2e7", "#94e2d5", "#a6adc8",
]

SESSION_COLORS = [
    "#89b4fa", "#a6e3a1", "#f9e2af", "#f38ba8",
    "#f5c2e7", "#94e2d5", "#fab387", "#b4befe",
    "#74c7ec", "#cba6f7",
]

KEY_MAP = {
    "Enter": "\n",
    "Tab": "\t",
    "Escape": "\x1b",
    "Ctrl+C": "\x03",
    "Ctrl+D": "\x04",
}

CSS = f"""
window {{
    background-color: {CATPPUCCIN['base']};
}}
.sidebar {{
    background-color: {CATPPUCCIN['mantle']};
    border-right: 1px solid {CATPPUCCIN['surface0']};
}}
.sidebar-header {{
    background-color: {CATPPUCCIN['crust']};
    padding: 8px 12px;
    font-weight: bold;
    font-size: 13px;
    color: {CATPPUCCIN['blue']};
    border-bottom: 1px solid {CATPPUCCIN['surface0']};
}}
.sidebar-btn {{
    background: {CATPPUCCIN['surface0']};
    border: none;
    border-radius: 4px;
    color: {CATPPUCCIN['text']};
    padding: 4px 10px;
    min-height: 28px;
}}
.sidebar-btn:hover {{
    background: {CATPPUCCIN['surface1']};
}}
.sidebar-btn:active {{
    background: {CATPPUCCIN['surface2']};
}}
notebook header tab {{
    background: {CATPPUCCIN['mantle']};
    color: {CATPPUCCIN['subtext0']};
    border: none;
    padding: 4px 12px;
    border-radius: 6px 6px 0 0;
    margin: 0 1px;
}}
notebook header tab:checked {{
    background: {CATPPUCCIN['surface0']};
    color: {CATPPUCCIN['text']};
}}
notebook header {{
    background: {CATPPUCCIN['crust']};
}}
notebook {{
    background: {CATPPUCCIN['base']};
}}
treeview {{
    background-color: {CATPPUCCIN['mantle']};
    color: {CATPPUCCIN['text']};
}}
treeview:selected {{
    background-color: {CATPPUCCIN['surface1']};
    color: {CATPPUCCIN['text']};
}}
treeview:hover {{
    background-color: {CATPPUCCIN['surface0']};
}}
.tab-close-btn {{
    background: transparent;
    border: none;
    border-radius: 4px;
    padding: 0;
    min-width: 20px;
    min-height: 20px;
    color: {CATPPUCCIN['overlay1']};
}}
.tab-close-btn:hover {{
    background: {CATPPUCCIN['surface2']};
    color: {CATPPUCCIN['red']};
}}
stackswitcher {{
    background: {CATPPUCCIN['crust']};
    border-bottom: 1px solid {CATPPUCCIN['surface0']};
}}
stackswitcher button {{
    background: {CATPPUCCIN['crust']};
    color: {CATPPUCCIN['subtext0']};
    border: none;
    border-radius: 0;
    padding: 6px 16px;
    border-bottom: 2px solid transparent;
    font-weight: bold;
    font-size: 12px;
}}
stackswitcher button:checked {{
    background: {CATPPUCCIN['mantle']};
    color: {CATPPUCCIN['blue']};
    border-bottom: 2px solid {CATPPUCCIN['blue']};
}}
stackswitcher button:hover {{
    background: {CATPPUCCIN['surface0']};
}}
textview.ctx-detail {{
    font-family: monospace;
    font-size: 10pt;
}}
textview.ctx-detail text {{
    background-color: {CATPPUCCIN['crust']};
    color: {CATPPUCCIN['subtext1']};
}}
"""


def _parse_color(hex_str):
    """Parse hex color string to Gdk.RGBA."""
    c = Gdk.RGBA()
    c.parse(hex_str)
    return c


# ─── SessionManager ──────────────────────────────────────────────────────────


class SessionManager:
    """Zarządzanie zapisanymi sesjami SSH (CRUD + plik JSON)."""

    def __init__(self):
        os.makedirs(CONFIG_DIR, exist_ok=True)
        self.sessions = []
        self.load()

    def load(self):
        if os.path.exists(SESSIONS_FILE):
            try:
                with open(SESSIONS_FILE, "r") as f:
                    self.sessions = json.load(f)
            except (json.JSONDecodeError, IOError):
                self.sessions = []
        else:
            self.sessions = []

    def save(self):
        os.makedirs(CONFIG_DIR, exist_ok=True)
        fd, tmp = tempfile.mkstemp(dir=CONFIG_DIR, suffix=".tmp")
        try:
            with os.fdopen(fd, "w") as f:
                json.dump(self.sessions, f, indent=2)
            os.replace(tmp, SESSIONS_FILE)
        except Exception:
            if os.path.exists(tmp):
                os.unlink(tmp)
            raise

    def add(self, session):
        session["id"] = str(uuid.uuid4())
        self.sessions.append(session)
        self.save()
        return session

    def update(self, session_id, data):
        for i, s in enumerate(self.sessions):
            if s["id"] == session_id:
                self.sessions[i].update(data)
                self.save()
                return self.sessions[i]
        return None

    def delete(self, session_id):
        self.sessions = [s for s in self.sessions if s["id"] != session_id]
        self.save()

    def get(self, session_id):
        for s in self.sessions:
            if s["id"] == session_id:
                return s
        return None

    def all(self):
        return list(self.sessions)


# ─── ClaudeSessionManager ────────────────────────────────────────────────────


class ClaudeSessionManager:
    """Zarządzanie zapisanymi konfiguracjami Claude Code (CRUD + plik JSON)."""

    def __init__(self):
        os.makedirs(CONFIG_DIR, exist_ok=True)
        self.sessions = []
        self.load()

    def load(self):
        if os.path.exists(CLAUDE_SESSIONS_FILE):
            try:
                with open(CLAUDE_SESSIONS_FILE, "r") as f:
                    self.sessions = json.load(f)
            except (json.JSONDecodeError, IOError):
                self.sessions = []
        else:
            self.sessions = []

    def save(self):
        os.makedirs(CONFIG_DIR, exist_ok=True)
        fd, tmp = tempfile.mkstemp(dir=CONFIG_DIR, suffix=".tmp")
        try:
            with os.fdopen(fd, "w") as f:
                json.dump(self.sessions, f, indent=2)
            os.replace(tmp, CLAUDE_SESSIONS_FILE)
        except Exception:
            if os.path.exists(tmp):
                os.unlink(tmp)
            raise

    def add(self, session):
        session["id"] = str(uuid.uuid4())
        self.sessions.append(session)
        self.save()
        return session

    def update(self, session_id, data):
        for i, s in enumerate(self.sessions):
            if s["id"] == session_id:
                self.sessions[i].update(data)
                self.save()
                return self.sessions[i]
        return None

    def delete(self, session_id):
        self.sessions = [s for s in self.sessions if s["id"] != session_id]
        self.save()

    def get(self, session_id):
        for s in self.sessions:
            if s["id"] == session_id:
                return s
        return None

    def all(self):
        return list(self.sessions)


# ─── SessionDialog ────────────────────────────────────────────────────────────


class SessionDialog(Gtk.Dialog):
    """Dialog dodawania/edycji sesji SSH."""

    def __init__(self, parent, session=None):
        title = "Edit Session" if session else "Add Session"
        super().__init__(
            title=title,
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OK, Gtk.ResponseType.OK,
        )
        self.set_default_size(420, -1)
        self.set_default_response(Gtk.ResponseType.OK)

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(8)

        grid = Gtk.Grid(column_spacing=12, row_spacing=8)
        box.pack_start(grid, True, True, 0)

        labels = ["Name:", "Host:", "Port:", "Username:", "SSH Key:", "Folder:", "Color:"]
        for i, text in enumerate(labels):
            lbl = Gtk.Label(label=text, halign=Gtk.Align.END)
            grid.attach(lbl, 0, i, 1, 1)

        self.entry_name = Gtk.Entry(hexpand=True)
        self.entry_host = Gtk.Entry(hexpand=True)
        self.entry_port = Gtk.SpinButton.new_with_range(1, 65535, 1)
        self.entry_port.set_value(22)
        self.entry_username = Gtk.Entry(hexpand=True)
        self.entry_key = Gtk.Entry(hexpand=True)
        self.entry_key.set_placeholder_text("(optional) path to private key")
        self.entry_folder = Gtk.Entry(hexpand=True)
        self.entry_folder.set_placeholder_text("(optional) folder for grouping")

        self.color_combo = Gtk.ComboBoxText()
        for c in SESSION_COLORS:
            self.color_combo.append(c, c)
        self.color_combo.set_active(0)

        grid.attach(self.entry_name, 1, 0, 1, 1)
        grid.attach(self.entry_host, 1, 1, 1, 1)
        grid.attach(self.entry_port, 1, 2, 1, 1)
        grid.attach(self.entry_username, 1, 3, 1, 1)
        grid.attach(self.entry_key, 1, 4, 1, 1)
        grid.attach(self.entry_folder, 1, 5, 1, 1)
        grid.attach(self.color_combo, 1, 6, 1, 1)

        # Edit mode: fill fields
        if session:
            self.entry_name.set_text(session.get("name", ""))
            self.entry_host.set_text(session.get("host", ""))
            self.entry_port.set_value(int(session.get("port", 22)))
            self.entry_username.set_text(session.get("username", ""))
            self.entry_key.set_text(session.get("key_file", ""))
            self.entry_folder.set_text(session.get("folder", ""))
            color = session.get("color", SESSION_COLORS[0])
            self.color_combo.set_active_id(color)

        self.show_all()

    def get_data(self):
        return {
            "name": self.entry_name.get_text().strip(),
            "host": self.entry_host.get_text().strip(),
            "port": int(self.entry_port.get_value()),
            "username": self.entry_username.get_text().strip(),
            "key_file": self.entry_key.get_text().strip(),
            "folder": self.entry_folder.get_text().strip(),
            "color": self.color_combo.get_active_id() or SESSION_COLORS[0],
        }

    def validate(self):
        data = self.get_data()
        if not data["name"]:
            self._show_error("Name is required.")
            return False
        if not data["host"]:
            self._show_error("Host is required.")
            return False
        if not data["username"]:
            self._show_error("Username is required.")
            return False
        return True

    def _show_error(self, msg):
        dlg = Gtk.MessageDialog(
            transient_for=self,
            modal=True,
            message_type=Gtk.MessageType.ERROR,
            buttons=Gtk.ButtonsType.OK,
            text=msg,
        )
        dlg.run()
        dlg.destroy()


# ─── MacroDialog ─────────────────────────────────────────────────────────────


class MacroStepRow(Gtk.ListBoxRow):
    """Single step row in the macro editor."""

    def __init__(self, step=None):
        super().__init__()
        box = Gtk.Box(spacing=6)
        box.set_border_width(4)

        self.type_combo = Gtk.ComboBoxText()
        for t in ("text", "key", "delay"):
            self.type_combo.append(t, t)
        self.type_combo.set_active_id("text")
        box.pack_start(self.type_combo, False, False, 0)

        self.stack = Gtk.Stack()

        # text entry
        self.text_entry = Gtk.Entry(hexpand=True)
        self.text_entry.set_placeholder_text("Text to send")
        self.stack.add_named(self.text_entry, "text")

        # key combo
        self.key_combo = Gtk.ComboBoxText()
        for k in ("Enter", "Tab", "Escape", "Ctrl+C", "Ctrl+D"):
            self.key_combo.append(k, k)
        self.key_combo.set_active(0)
        self.stack.add_named(self.key_combo, "key")

        # delay spin
        self.delay_spin = Gtk.SpinButton.new_with_range(100, 10000, 100)
        self.delay_spin.set_value(1000)
        self.stack.add_named(self.delay_spin, "delay")

        box.pack_start(self.stack, True, True, 0)
        self.add(box)

        self.type_combo.connect("changed", self._on_type_changed)

        if step:
            self.type_combo.set_active_id(step["type"])
            if step["type"] == "text":
                self.text_entry.set_text(step["value"])
            elif step["type"] == "key":
                self.key_combo.set_active_id(step["value"])
            elif step["type"] == "delay":
                self.delay_spin.set_value(int(step["value"]))

        self._on_type_changed(self.type_combo)
        self.show_all()

    def _on_type_changed(self, combo):
        active = combo.get_active_id()
        if active:
            self.stack.set_visible_child_name(active)

    def get_step(self):
        t = self.type_combo.get_active_id()
        if t == "text":
            return {"type": "text", "value": self.text_entry.get_text()}
        elif t == "key":
            return {"type": "key", "value": self.key_combo.get_active_id()}
        elif t == "delay":
            return {"type": "delay", "value": int(self.delay_spin.get_value())}
        return {"type": "text", "value": ""}


class MacroDialog(Gtk.Dialog):
    """Dialog do dodawania/edycji makra SSH."""

    def __init__(self, parent, macro=None):
        title = "Edit Macro" if macro else "Add Macro"
        super().__init__(
            title=title,
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OK, Gtk.ResponseType.OK,
        )
        self.set_default_size(500, 400)
        self.set_default_response(Gtk.ResponseType.OK)

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(8)

        # Name
        name_box = Gtk.Box(spacing=8)
        name_box.pack_start(Gtk.Label(label="Name:"), False, False, 0)
        self.entry_name = Gtk.Entry(hexpand=True)
        name_box.pack_start(self.entry_name, True, True, 0)
        box.pack_start(name_box, False, False, 0)

        # Steps label
        box.pack_start(Gtk.Label(label="Steps:", halign=Gtk.Align.START), False, False, 0)

        # Steps listbox in scrolled window
        scrolled = Gtk.ScrolledWindow()
        scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scrolled.set_min_content_height(200)
        self.listbox = Gtk.ListBox()
        self.listbox.set_selection_mode(Gtk.SelectionMode.SINGLE)
        scrolled.add(self.listbox)
        box.pack_start(scrolled, True, True, 0)

        # Buttons
        btn_box = Gtk.Box(spacing=4)
        for label_text, cb in [
            ("Add Step", self._on_add),
            ("Remove", self._on_remove),
            ("Move Up", self._on_move_up),
            ("Move Down", self._on_move_down),
        ]:
            btn = Gtk.Button(label=label_text)
            btn.connect("clicked", cb)
            btn_box.pack_start(btn, True, True, 0)
        box.pack_start(btn_box, False, False, 0)

        # Quick-add shortcuts
        box.pack_start(Gtk.Separator(), False, False, 2)
        quick_label = Gtk.Label(label="Quick add:", halign=Gtk.Align.START)
        quick_label.set_opacity(0.6)
        box.pack_start(quick_label, False, False, 0)

        quick_box = Gtk.Box(spacing=4)
        for key_name in ("Enter", "Tab", "Escape", "Ctrl+C", "Ctrl+D"):
            btn = Gtk.Button(label=key_name)
            btn.connect("clicked", self._on_quick_key, key_name)
            quick_box.pack_start(btn, True, True, 0)
        box.pack_start(quick_box, False, False, 0)

        delay_box = Gtk.Box(spacing=6)
        btn_delay = Gtk.Button(label="+ Delay")
        self.delay_spin = Gtk.SpinButton.new_with_range(100, 10000, 100)
        self.delay_spin.set_value(500)
        lbl_ms = Gtk.Label(label="ms")
        btn_delay.connect("clicked", self._on_quick_delay)
        delay_box.pack_start(btn_delay, False, False, 0)
        delay_box.pack_start(self.delay_spin, False, False, 0)
        delay_box.pack_start(lbl_ms, False, False, 0)
        box.pack_start(delay_box, False, False, 0)

        # Fill if editing
        if macro:
            self.entry_name.set_text(macro.get("name", ""))
            for step in macro.get("steps", []):
                self.listbox.add(MacroStepRow(step))

        self.show_all()

    def _on_quick_key(self, btn, key_name):
        row = MacroStepRow({"type": "key", "value": key_name})
        self.listbox.add(row)

    def _on_quick_delay(self, btn):
        ms = int(self.delay_spin.get_value())
        row = MacroStepRow({"type": "delay", "value": ms})
        self.listbox.add(row)

    def _on_add(self, btn):
        row = MacroStepRow()
        self.listbox.add(row)

    def _on_remove(self, btn):
        row = self.listbox.get_selected_row()
        if row:
            self.listbox.remove(row)

    def _on_move_up(self, btn):
        row = self.listbox.get_selected_row()
        if row:
            idx = row.get_index()
            if idx > 0:
                step = row.get_step()
                self.listbox.remove(row)
                new_row = MacroStepRow(step)
                self.listbox.insert(new_row, idx - 1)
                self.listbox.select_row(new_row)

    def _on_move_down(self, btn):
        row = self.listbox.get_selected_row()
        if row:
            idx = row.get_index()
            n = len(self.listbox.get_children())
            if idx < n - 1:
                step = row.get_step()
                self.listbox.remove(row)
                new_row = MacroStepRow(step)
                self.listbox.insert(new_row, idx + 1)
                self.listbox.select_row(new_row)

    def get_data(self):
        steps = []
        for row in self.listbox.get_children():
            steps.append(row.get_step())
        return {
            "name": self.entry_name.get_text().strip(),
            "steps": steps,
        }

    def validate(self):
        data = self.get_data()
        if not data["name"]:
            self._show_error("Macro name is required.")
            return False
        if not data["steps"]:
            self._show_error("At least one step is required.")
            return False
        return True

    def _show_error(self, msg):
        dlg = Gtk.MessageDialog(
            transient_for=self,
            modal=True,
            message_type=Gtk.MessageType.ERROR,
            buttons=Gtk.ButtonsType.OK,
            text=msg,
        )
        dlg.run()
        dlg.destroy()


# ─── ClaudeCodeDialog ─────────────────────────────────────────────────────────


class ClaudeCodeDialog(Gtk.Dialog):
    """Dialog konfiguracji sesji Claude Code."""

    def __init__(self, parent, session=None):
        title = "Edit Claude Session" if session else "Add Claude Session"
        super().__init__(
            title=title,
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OK, Gtk.ResponseType.OK,
        )
        self.set_default_size(460, -1)
        self.set_default_response(Gtk.ResponseType.OK)

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(10)

        # Name, Folder, Color grid
        grid = Gtk.Grid(column_spacing=12, row_spacing=8)
        box.pack_start(grid, False, False, 0)

        for i, text in enumerate(["Name:", "Folder:", "Color:", "Project dir:"]):
            lbl = Gtk.Label(label=text, halign=Gtk.Align.END)
            grid.attach(lbl, 0, i, 1, 1)

        self.entry_name = Gtk.Entry(hexpand=True)
        grid.attach(self.entry_name, 1, 0, 1, 1)

        self.entry_folder = Gtk.Entry(hexpand=True)
        self.entry_folder.set_placeholder_text("(optional) folder for grouping")
        grid.attach(self.entry_folder, 1, 1, 1, 1)

        self.color_combo = Gtk.ComboBoxText()
        for c in SESSION_COLORS:
            self.color_combo.append(c, c)
        self.color_combo.set_active(0)
        grid.attach(self.color_combo, 1, 2, 1, 1)

        dir_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
        self.entry_project_dir = Gtk.Entry(hexpand=True)
        self.entry_project_dir.set_placeholder_text("(optional) path to project directory")
        dir_box.pack_start(self.entry_project_dir, True, True, 0)
        btn_browse = Gtk.Button(label="Browse…")
        btn_browse.connect("clicked", self._on_browse_dir)
        dir_box.pack_start(btn_browse, False, False, 0)
        grid.attach(dir_box, 1, 3, 1, 1)

        self.lbl_ctx_status = Gtk.Label(xalign=0)
        grid.attach(self.lbl_ctx_status, 1, 4, 1, 1)

        # Separator
        box.pack_start(Gtk.Separator(), False, False, 2)

        # Sudo checkbox
        self.chk_sudo = Gtk.CheckButton(label="Run with sudo (asks for password)")
        box.pack_start(self.chk_sudo, False, False, 0)

        # Resume session checkbox
        self.chk_resume = Gtk.CheckButton(label="Resume last session (--resume)")
        self.chk_resume.set_active(True)
        box.pack_start(self.chk_resume, False, False, 0)

        # Skip permissions checkbox
        self.chk_skip_perms = Gtk.CheckButton(label="Skip permissions (--dangerously-skip-permissions)")
        self.chk_skip_perms.set_active(True)
        box.pack_start(self.chk_skip_perms, False, False, 0)

        # Initial prompt
        lbl = Gtk.Label(label="Initial prompt (optional):", halign=Gtk.Align.START)
        box.pack_start(lbl, False, False, 0)

        scrolled = Gtk.ScrolledWindow()
        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        scrolled.set_min_content_height(80)
        self.textview = Gtk.TextView()
        self.textview.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        scrolled.add(self.textview)
        box.pack_start(scrolled, True, True, 0)

        # Edit mode: fill fields
        if session:
            self.entry_name.set_text(session.get("name", ""))
            self.entry_folder.set_text(session.get("folder", ""))
            color = session.get("color", SESSION_COLORS[0])
            self.color_combo.set_active_id(color)
            self.chk_sudo.set_active(session.get("sudo", False))
            self.chk_resume.set_active(session.get("resume", True))
            self.chk_skip_perms.set_active(session.get("skip_permissions", True))
            self.entry_project_dir.set_text(session.get("project_dir", ""))
            prompt = session.get("prompt", "")
            if prompt:
                self.textview.get_buffer().set_text(prompt)

        self.show_all()
        self._update_ctx_status()

    def get_data(self):
        buf = self.textview.get_buffer()
        start, end = buf.get_bounds()
        prompt = buf.get_text(start, end, False).strip()
        return {
            "name": self.entry_name.get_text().strip(),
            "folder": self.entry_folder.get_text().strip(),
            "color": self.color_combo.get_active_id() or SESSION_COLORS[0],
            "sudo": self.chk_sudo.get_active(),
            "resume": self.chk_resume.get_active(),
            "skip_permissions": self.chk_skip_perms.get_active(),
            "prompt": prompt,
            "project_dir": self.entry_project_dir.get_text().strip(),
        }

    def validate(self):
        data = self.get_data()
        if not data["name"]:
            self._show_error("Name is required.")
            return False
        return True

    def _show_error(self, msg):
        dlg = Gtk.MessageDialog(
            transient_for=self,
            modal=True,
            message_type=Gtk.MessageType.ERROR,
            buttons=Gtk.ButtonsType.OK,
            text=msg,
        )
        dlg.run()
        dlg.destroy()

    def _on_browse_dir(self, button):
        dlg = Gtk.FileChooserDialog(
            title="Select project directory",
            parent=self,
            action=Gtk.FileChooserAction.SELECT_FOLDER,
        )
        dlg.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OPEN, Gtk.ResponseType.OK,
        )
        if dlg.run() == Gtk.ResponseType.OK:
            path = dlg.get_filename()
            self.entry_project_dir.set_text(path)
            basename = os.path.basename(path.rstrip("/"))
            if not self.entry_name.get_text().strip():
                self.entry_name.set_text(basename)
            # Auto-fill prompt with ctx instructions if empty or auto-generated
            buf = self.textview.get_buffer()
            start, end = buf.get_bounds()
            current = buf.get_text(start, end, False).strip()
            if not current or current.startswith("Wczytaj kontekst"):
                prompt = (
                    f"Wczytaj kontekst projektu poleceniem: ctx get {basename}\n"
                    f"Wykonaj tę komendę i zapoznaj się z kontekstem zanim zaczniesz pracę.\n"
                    f"Kontekst zarządzasz przez: ctx --help\n"
                    f"Ważne odkrycia zapisuj: ctx set {basename} <key> <value>\n"
                    f"Przed zakończeniem sesji: ctx summary {basename} \"<co zrobiliśmy>\""
                )
                buf.set_text(prompt)
            self._update_ctx_status()
        dlg.destroy()

    def _update_ctx_status(self):
        project_dir = self.entry_project_dir.get_text().strip()
        if not project_dir:
            self.lbl_ctx_status.set_text("")
            return
        name = os.path.basename(project_dir.rstrip("/"))
        if _is_ctx_project_registered(name):
            self.lbl_ctx_status.set_markup(
                '<small>\u2713 Ctx project "<b>'
                + GLib.markup_escape_text(name)
                + '</b>" is registered</small>'
            )
        else:
            self.lbl_ctx_status.set_markup(
                "<small>\u2139 New project \u2014 ctx wizard will guide you after save</small>"
            )


# ─── CtxEditDialog ────────────────────────────────────────────────────────────


CTX_DB = os.path.join(os.path.expanduser("~"), ".claude-context", "context.db")


def _detect_project_description(project_dir):
    """Detect project description from README or directory name."""
    for name in ["README.md", "README.rst", "README.txt", "README"]:
        readme_path = os.path.join(project_dir, name)
        if os.path.isfile(readme_path):
            try:
                with open(readme_path, "r") as f:
                    for line in f:
                        line = line.strip().lstrip("#").strip()
                        if line:
                            return line[:100]
            except (IOError, UnicodeDecodeError):
                pass
    return os.path.basename(project_dir.rstrip("/"))


def _is_ctx_project_registered(project_name):
    """Check if a ctx project is already registered in the database."""
    if not os.path.exists(CTX_DB):
        return False
    import sqlite3
    try:
        db = sqlite3.connect(CTX_DB)
        row = db.execute(
            "SELECT 1 FROM sessions WHERE name = ?", (project_name,)
        ).fetchone()
        db.close()
        return row is not None
    except sqlite3.Error:
        return False


def _is_ctx_available():
    """Check if ctx command is available."""
    try:
        subprocess.run(["ctx", "--version"], capture_output=True, timeout=5)
        return True
    except (FileNotFoundError, subprocess.TimeoutExpired):
        return False


def _run_ctx_wizard_if_needed(parent, data):
    """Launch ctx wizard if project_dir is set but ctx not registered. Returns updated data."""
    project_dir = data.get("project_dir", "")
    if not project_dir or not _is_ctx_available():
        return data
    project_name = os.path.basename(project_dir.rstrip("/"))
    if _is_ctx_project_registered(project_name):
        return data
    wizard = CtxSetupWizard(parent, project_dir)
    if wizard.run_wizard():
        if not data["prompt"] or data["prompt"].startswith("Wczytaj kontekst"):
            data["prompt"] = wizard.result_prompt
    return data


_WIZARD_BACK = 1
_WIZARD_NEXT = 2


class CtxSetupWizard(Gtk.Dialog):
    """Step-by-step wizard for initial ctx project setup."""

    def __init__(self, parent, project_dir):
        super().__init__(
            title="Ctx — New Project Setup",
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.set_default_size(540, -1)
        self.set_resizable(False)
        self.project_dir = project_dir
        self.project_name = os.path.basename(project_dir.rstrip("/"))
        self.success = False
        self.result_prompt = ""
        self._current_page = 0

        box = self.get_content_area()
        box.set_border_width(16)
        box.set_spacing(12)

        # Page header
        self.lbl_header = Gtk.Label(xalign=0)
        box.pack_start(self.lbl_header, False, False, 0)
        box.pack_start(Gtk.Separator(), False, False, 0)

        # Stack for pages
        self.stack = Gtk.Stack()
        self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
        box.pack_start(self.stack, True, True, 0)

        # Status bar (for errors)
        self.lbl_status = Gtk.Label(xalign=0, wrap=True, max_width_chars=60)
        box.pack_start(self.lbl_status, False, False, 0)

        self._build_page_project()
        self._build_page_entry()
        self._build_page_confirm()

        # Navigation buttons
        self.btn_cancel = self.add_button("Cancel", Gtk.ResponseType.CANCEL)
        self.btn_back = self.add_button("\u2190 Back", _WIZARD_BACK)
        self.btn_next = self.add_button("Next \u2192", _WIZARD_NEXT)
        self.btn_finish = self.add_button("\u2713 Create", Gtk.ResponseType.OK)

        self._show_page(0)
        self.show_all()

    def _build_page_project(self):
        page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)

        info = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
        info.set_markup(
            "Register the project in the ctx database.\n"
            "The <b>project name</b> is used in all ctx commands "
            "(e.g. <tt>ctx get MyProject</tt>).\n"
            "<b>Description</b> helps Claude understand the project purpose."
        )
        page.pack_start(info, False, False, 0)

        warn = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
        warn.set_markup(
            '<small>\u26a0 Case matters! "<tt>MyProject</tt>" \u2260 '
            '"<tt>myproject</tt>". The name must match exactly in all commands.</small>'
        )
        page.pack_start(warn, False, False, 4)

        grid = Gtk.Grid(column_spacing=12, row_spacing=8)

        grid.attach(Gtk.Label(label="Directory:", halign=Gtk.Align.END), 0, 0, 1, 1)
        lbl_dir = Gtk.Label(
            label=self.project_dir, halign=Gtk.Align.START,
            selectable=True, ellipsize=Pango.EllipsizeMode.MIDDLE,
        )
        grid.attach(lbl_dir, 1, 0, 1, 1)

        grid.attach(Gtk.Label(label="Project name:", halign=Gtk.Align.END), 0, 1, 1, 1)
        self.w_name = Gtk.Entry(hexpand=True)
        self.w_name.set_text(self.project_name)
        grid.attach(self.w_name, 1, 1, 1, 1)

        grid.attach(Gtk.Label(label="Description:", halign=Gtk.Align.END), 0, 2, 1, 1)
        self.w_desc = Gtk.Entry(hexpand=True)
        self.w_desc.set_text(_detect_project_description(self.project_dir))
        grid.attach(self.w_desc, 1, 2, 1, 1)

        page.pack_start(grid, False, False, 0)
        self.stack.add_named(page, "project")

    def _build_page_entry(self):
        page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)

        info = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
        info.set_markup(
            "Add the <b>first context entry</b>. Claude reads these at the start "
            "of each session to understand the project.\n\n"
            "Examples:\n"
            '  Key: <tt>repo</tt>  Value: <tt>GitHub: .../MyRepo, branch: main</tt>\n'
            '  Key: <tt>stack</tt>  Value: <tt>Python 3.12, Flask, PostgreSQL</tt>'
        )
        page.pack_start(info, False, False, 0)

        grid = Gtk.Grid(column_spacing=12, row_spacing=8)

        grid.attach(Gtk.Label(label="Key:", halign=Gtk.Align.END), 0, 0, 1, 1)
        self.w_key = Gtk.Entry(hexpand=True)
        self.w_key.set_placeholder_text("e.g. repo, stack, architecture")
        grid.attach(self.w_key, 1, 0, 1, 1)

        grid.attach(
            Gtk.Label(label="Value:", halign=Gtk.Align.END, valign=Gtk.Align.START),
            0, 1, 1, 1,
        )
        scrolled = Gtk.ScrolledWindow()
        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        scrolled.set_min_content_height(90)
        self.w_value = Gtk.TextView(wrap_mode=Gtk.WrapMode.WORD_CHAR)
        scrolled.add(self.w_value)
        grid.attach(scrolled, 1, 1, 1, 1)

        page.pack_start(grid, True, True, 0)
        self.stack.add_named(page, "entry")

    def _build_page_confirm(self):
        page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)

        info = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
        info.set_text("Review and confirm. The following actions will be performed:")
        page.pack_start(info, False, False, 0)

        self.lbl_summary = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
        page.pack_start(self.lbl_summary, False, False, 0)

        page.pack_start(Gtk.Separator(), False, False, 4)
        self.stack.add_named(page, "confirm")

    def _show_page(self, idx):
        self._current_page = idx
        pages = ["project", "entry", "confirm"]
        self.stack.set_visible_child_name(pages[idx])
        self.lbl_status.set_text("")

        headers = [
            "Step 1 of 3: Project registration",
            "Step 2 of 3: First context entry",
            "Step 3 of 3: Confirm and create",
        ]
        self.lbl_header.set_markup(f"<b>{headers[idx]}</b>")

        if idx == 2:
            self._update_summary()

    def _update_buttons(self):
        idx = self._current_page
        self.btn_back.set_visible(idx > 0)
        self.btn_next.set_visible(idx < 2)
        self.btn_finish.set_visible(idx == 2)

    def _update_summary(self):
        name = self.w_name.get_text().strip()
        desc = self.w_desc.get_text().strip()
        key = self.w_key.get_text().strip()
        buf = self.w_value.get_buffer()
        s, e = buf.get_bounds()
        value = buf.get_text(s, e, False).strip()
        val_preview = value[:150] + ("\u2026" if len(value) > 150 else "")

        self.lbl_summary.set_markup(
            f"<tt>1.</tt> <tt>ctx init</tt> \u2014 register project "
            f"<b>{GLib.markup_escape_text(name)}</b>\n"
            f"     {GLib.markup_escape_text(desc)}\n\n"
            f"<tt>2.</tt> <tt>ctx set</tt> \u2014 add entry "
            f"<b>{GLib.markup_escape_text(key)}</b>\n"
            f"     {GLib.markup_escape_text(val_preview)}\n\n"
            f"<tt>3.</tt> Create <tt>CLAUDE.md</tt> in project directory\n"
            f"     (will be skipped if file already exists)"
        )

    def _validate_page(self, idx):
        if idx == 0:
            name = self.w_name.get_text().strip()
            desc = self.w_desc.get_text().strip()
            if not name:
                self.lbl_status.set_markup(
                    '<span foreground="red">Project name is required.</span>'
                )
                self.w_name.grab_focus()
                return False
            if not desc:
                self.lbl_status.set_markup(
                    '<span foreground="red">Description is required.</span>'
                )
                self.w_desc.grab_focus()
                return False
        elif idx == 1:
            key = self.w_key.get_text().strip()
            buf = self.w_value.get_buffer()
            s, e = buf.get_bounds()
            value = buf.get_text(s, e, False).strip()
            if not key:
                self.lbl_status.set_markup(
                    '<span foreground="red">Key is required. '
                    'E.g. "repo", "stack", "notes".</span>'
                )
                self.w_key.grab_focus()
                return False
            if not value:
                self.lbl_status.set_markup(
                    '<span foreground="red">Value is required. '
                    "Describe something about the project.</span>"
                )
                self.w_value.grab_focus()
                return False
        return True

    def _execute(self):
        """Run ctx init, ctx set, and create CLAUDE.md."""
        name = self.w_name.get_text().strip()
        desc = self.w_desc.get_text().strip()
        key = self.w_key.get_text().strip()
        buf = self.w_value.get_buffer()
        s, e = buf.get_bounds()
        value = buf.get_text(s, e, False).strip()

        # 1. ctx init
        try:
            r = subprocess.run(
                ["ctx", "init", name, desc, self.project_dir],
                capture_output=True, text=True,
            )
            if r.returncode != 0:
                self.lbl_status.set_markup(
                    f'<span foreground="red">ctx init failed: '
                    f"{GLib.markup_escape_text(r.stderr.strip())}</span>"
                )
                return False
        except FileNotFoundError:
            self.lbl_status.set_markup(
                '<span foreground="red">ctx command not found.</span>'
            )
            return False

        # 2. ctx set
        try:
            r = subprocess.run(
                ["ctx", "set", name, key, value],
                capture_output=True, text=True,
            )
            if r.returncode != 0:
                self.lbl_status.set_markup(
                    f'<span foreground="red">ctx set failed: '
                    f"{GLib.markup_escape_text(r.stderr.strip())}</span>"
                )
                return False
        except FileNotFoundError:
            return False

        # 3. CLAUDE.md
        claude_md = os.path.join(self.project_dir, "CLAUDE.md")
        if not os.path.exists(claude_md):
            try:
                with open(claude_md, "w") as f:
                    f.write(
                        f"# {name}\n\n"
                        f"On session start, load context:\n"
                        f"```bash\n"
                        f"ctx get {name}\n"
                        f"```\n\n"
                        f"Context manager: `ctx --help`\n\n"
                        f"During work:\n"
                        f"- Save important discoveries: `ctx set {name} <key> <value>`\n"
                        f"- Append to existing: `ctx append {name} <key> <value>`\n"
                        f'- Before ending session: `ctx summary {name} "<what was done>"`\n'
                    )
            except IOError as e:
                self.lbl_status.set_markup(
                    f'<span foreground="red">CLAUDE.md: {GLib.markup_escape_text(str(e))}</span>'
                )
                return False

        self.project_name = name
        self.result_prompt = (
            f"Wczytaj kontekst projektu poleceniem: ctx get {name}\n"
            f"Wykonaj t\u0119 komend\u0119 i zapoznaj si\u0119 z kontekstem zanim zaczniesz prac\u0119.\n"
            f"Kontekst zarz\u0105dzasz przez: ctx --help\n"
            f"Wa\u017cne odkrycia zapisuj: ctx set {name} <key> <value>\n"
            f'Przed zako\u0144czeniem sesji: ctx summary {name} "<co zrobili\u015bmy>"'
        )
        self.success = True
        return True

    def run_wizard(self):
        """Run the wizard. Returns True if completed successfully."""
        while True:
            self._update_buttons()
            resp = self.run()
            if resp == _WIZARD_NEXT:
                if self._validate_page(self._current_page):
                    self._show_page(self._current_page + 1)
            elif resp == _WIZARD_BACK:
                self._show_page(self._current_page - 1)
            elif resp == Gtk.ResponseType.OK:
                if self._execute():
                    self.destroy()
                    return True
            else:
                self.destroy()
                return False


class _CtxEntryDialog(Gtk.Dialog):
    """Small dialog for adding/editing a ctx key-value entry."""

    def __init__(self, parent, title, key="", value=""):
        super().__init__(
            title=title,
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OK, Gtk.ResponseType.OK,
        )
        self.set_default_size(400, -1)
        self.set_default_response(Gtk.ResponseType.OK)

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(8)

        grid = Gtk.Grid(column_spacing=12, row_spacing=8)
        box.pack_start(grid, True, True, 0)

        grid.attach(Gtk.Label(label="Key:", halign=Gtk.Align.END), 0, 0, 1, 1)
        self.entry_key = Gtk.Entry(hexpand=True)
        self.entry_key.set_text(key)
        grid.attach(self.entry_key, 1, 0, 1, 1)

        grid.attach(Gtk.Label(label="Value:", halign=Gtk.Align.END, valign=Gtk.Align.START), 0, 1, 1, 1)
        scrolled = Gtk.ScrolledWindow()
        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        scrolled.set_min_content_height(100)
        self.textview = Gtk.TextView()
        self.textview.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        if value:
            self.textview.get_buffer().set_text(value)
        scrolled.add(self.textview)
        grid.attach(scrolled, 1, 1, 1, 1)

        self.show_all()

    def get_data(self):
        key = self.entry_key.get_text().strip()
        buf = self.textview.get_buffer()
        start, end = buf.get_bounds()
        value = buf.get_text(start, end, False).strip()
        return key, value


class _CtxProjectDialog(Gtk.Dialog):
    """Dialog for adding/editing a ctx project."""

    def __init__(self, parent, title="New Project", name="", description="", work_dir=""):
        super().__init__(
            title=title,
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OK, Gtk.ResponseType.OK,
        )
        self.set_default_size(450, -1)
        self.set_default_response(Gtk.ResponseType.OK)

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(8)

        grid = Gtk.Grid(column_spacing=12, row_spacing=8)
        box.pack_start(grid, True, True, 0)

        grid.attach(Gtk.Label(label="Name:", halign=Gtk.Align.END), 0, 0, 1, 1)
        self.entry_name = Gtk.Entry(hexpand=True)
        self.entry_name.set_text(name)
        grid.attach(self.entry_name, 1, 0, 1, 1)

        grid.attach(Gtk.Label(label="Description:", halign=Gtk.Align.END), 0, 1, 1, 1)
        self.entry_desc = Gtk.Entry(hexpand=True)
        self.entry_desc.set_text(description)
        grid.attach(self.entry_desc, 1, 1, 1, 1)

        grid.attach(Gtk.Label(label="Directory:", halign=Gtk.Align.END), 0, 2, 1, 1)
        dir_box = Gtk.Box(spacing=4)
        self.entry_dir = Gtk.Entry(hexpand=True)
        self.entry_dir.set_text(work_dir)
        self.entry_dir.set_placeholder_text("(optional) path to project directory")
        dir_box.pack_start(self.entry_dir, True, True, 0)
        btn_browse = Gtk.Button(label="Browse\u2026")
        btn_browse.connect("clicked", self._on_browse)
        dir_box.pack_start(btn_browse, False, False, 0)
        grid.attach(dir_box, 1, 2, 1, 1)

        self.show_all()

    def _on_browse(self, button):
        dlg = Gtk.FileChooserDialog(
            title="Select directory",
            parent=self,
            action=Gtk.FileChooserAction.SELECT_FOLDER,
        )
        dlg.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OPEN, Gtk.ResponseType.OK,
        )
        if dlg.run() == Gtk.ResponseType.OK:
            path = dlg.get_filename()
            self.entry_dir.set_text(path)
            if not self.entry_name.get_text().strip():
                self.entry_name.set_text(os.path.basename(path.rstrip("/")))
        dlg.destroy()

    def get_data(self):
        return (
            self.entry_name.get_text().strip(),
            self.entry_desc.get_text().strip(),
            self.entry_dir.get_text().strip(),
        )


class CtxEditDialog(Gtk.Dialog):
    """Dialog to view and edit ctx project entries."""

    def __init__(self, parent, ctx_project, project_dir=""):
        super().__init__(
            title=f"Ctx: {ctx_project}",
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)
        self.set_default_size(550, 400)
        self.ctx_project = ctx_project
        self.project_dir = project_dir

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(8)

        # Description
        desc_box = Gtk.Box(spacing=8)
        desc_box.pack_start(Gtk.Label(label="Description:"), False, False, 0)
        self.entry_desc = Gtk.Entry(hexpand=True)
        desc_box.pack_start(self.entry_desc, True, True, 0)
        btn_save_desc = Gtk.Button(label="Save")
        btn_save_desc.connect("clicked", self._on_save_desc)
        desc_box.pack_start(btn_save_desc, False, False, 0)
        box.pack_start(desc_box, False, False, 0)

        box.pack_start(Gtk.Separator(), False, False, 2)

        # Entries list
        self.store = Gtk.ListStore(str, str)
        self.tree = Gtk.TreeView(model=self.store)
        self.tree.set_headers_visible(True)

        renderer_key = Gtk.CellRendererText()
        col_key = Gtk.TreeViewColumn("Key", renderer_key, text=0)
        col_key.set_min_width(120)
        self.tree.append_column(col_key)

        renderer_val = Gtk.CellRendererText()
        renderer_val.set_property("ellipsize", Pango.EllipsizeMode.END)
        col_val = Gtk.TreeViewColumn("Value", renderer_val, text=1)
        col_val.set_expand(True)
        self.tree.append_column(col_val)

        scrolled = Gtk.ScrolledWindow()
        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        scrolled.add(self.tree)
        box.pack_start(scrolled, True, True, 0)

        # Buttons
        btn_box = Gtk.Box(spacing=4)
        for label_text, cb in [("Add", self._on_add), ("Edit", self._on_edit), ("Delete", self._on_delete)]:
            btn = Gtk.Button(label=label_text)
            btn.connect("clicked", cb)
            btn_box.pack_start(btn, True, True, 0)
        box.pack_start(btn_box, False, False, 0)

        self._load_data()
        self.show_all()

    def _load_data(self):
        import sqlite3
        self.store.clear()
        if not os.path.exists(CTX_DB):
            return
        db = sqlite3.connect(CTX_DB)
        db.row_factory = sqlite3.Row
        session = db.execute(
            "SELECT description FROM sessions WHERE name = ?", (self.ctx_project,)
        ).fetchone()
        if session:
            self.entry_desc.set_text(session["description"] or "")
        entries = db.execute(
            "SELECT key, value FROM contexts WHERE project = ? ORDER BY key",
            (self.ctx_project,),
        ).fetchall()
        for row in entries:
            self.store.append([row["key"], row["value"]])
        db.close()

    def _on_save_desc(self, button):
        desc = self.entry_desc.get_text().strip()
        if desc:
            subprocess.run(
                ["ctx", "init", self.ctx_project, desc, self.project_dir],
                capture_output=True, text=True,
            )

    def _on_add(self, button):
        dlg = _CtxEntryDialog(self, "Add entry")
        if dlg.run() == Gtk.ResponseType.OK:
            key, value = dlg.get_data()
            if key:
                subprocess.run(
                    ["ctx", "set", self.ctx_project, key, value],
                    capture_output=True, text=True,
                )
                self._load_data()
        dlg.destroy()

    def _on_edit(self, button):
        sel = self.tree.get_selection()
        model, it = sel.get_selected()
        if it is None:
            return
        old_key = model.get_value(it, 0)
        old_value = model.get_value(it, 1)
        dlg = _CtxEntryDialog(self, "Edit entry", old_key, old_value)
        if dlg.run() == Gtk.ResponseType.OK:
            key, value = dlg.get_data()
            if key:
                if key != old_key:
                    subprocess.run(
                        ["ctx", "delete", self.ctx_project, old_key],
                        capture_output=True, text=True,
                    )
                subprocess.run(
                    ["ctx", "set", self.ctx_project, key, value],
                    capture_output=True, text=True,
                )
                self._load_data()
        dlg.destroy()

    def _on_delete(self, button):
        sel = self.tree.get_selection()
        model, it = sel.get_selected()
        if it is None:
            return
        key = model.get_value(it, 0)
        dlg = Gtk.MessageDialog(
            transient_for=self,
            modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=f'Delete entry "{key}"?',
        )
        if dlg.run() == Gtk.ResponseType.YES:
            subprocess.run(
                ["ctx", "delete", self.ctx_project, key],
                capture_output=True, text=True,
            )
            self._load_data()
        dlg.destroy()


# ─── TerminalTab ──────────────────────────────────────────────────────────────


class TerminalTab(Gtk.Box):
    """Zakładka terminala — lokalny shell lub SSH."""

    def __init__(self, app, session=None, claude_config=None):
        super().__init__(orientation=Gtk.Orientation.VERTICAL)
        self.app = app
        self.session = session
        self.claude_config = claude_config

        self.terminal = Vte.Terminal()
        self.terminal.set_font(Pango.FontDescription(FONT))
        self.terminal.set_scrollback_lines(SCROLLBACK_LINES)
        self.terminal.set_scroll_on_output(False)
        self.terminal.set_scroll_on_keystroke(True)
        self.terminal.set_audible_bell(False)

        # Catppuccin colors
        fg = _parse_color(CATPPUCCIN["text"])
        bg = _parse_color(CATPPUCCIN["base"])
        palette = [_parse_color(c) for c in TERMINAL_PALETTE]
        self.terminal.set_colors(fg, bg, palette)

        # Cursor color
        self.terminal.set_color_cursor(_parse_color(CATPPUCCIN["rosewater"]))
        self.terminal.set_color_cursor_foreground(_parse_color(CATPPUCCIN["crust"]))

        scrolled = Gtk.ScrolledWindow()
        scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scrolled.add(self.terminal)
        self.pack_start(scrolled, True, True, 0)

        self.terminal.connect("child-exited", self._on_child_exited)
        self.terminal.connect("window-title-changed", self._on_title_changed)
        self.terminal.connect("key-press-event", self._on_key_press)
        self.terminal.connect("button-press-event", self._on_button_press)

        self.show_all()

        if claude_config:
            self.spawn_claude(claude_config)
        elif session:
            self.spawn_ssh(
                session["host"],
                session.get("port", 22),
                session["username"],
                session.get("key_file", ""),
            )
        else:
            self.spawn_local_shell()

    def spawn_local_shell(self):
        shell = os.environ.get("SHELL", "/bin/bash")
        self.terminal.spawn_async(
            Vte.PtyFlags.DEFAULT,
            os.environ.get("HOME", "/"),
            [shell],
            None,
            GLib.SpawnFlags.DEFAULT,
            None,
            None,
            -1,
            None,
            None,
        )

    def spawn_ssh(self, host, port, username, key_file=""):
        argv = [SSH_PATH]
        if key_file:
            argv += ["-i", key_file]
        argv += ["-p", str(port), f"{username}@{host}"]

        self.terminal.spawn_async(
            Vte.PtyFlags.DEFAULT,
            os.environ.get("HOME", "/"),
            argv,
            None,
            GLib.SpawnFlags.DEFAULT,
            None,
            None,
            -1,
            None,
            None,
        )

    def spawn_claude(self, config):
        """Spawn Claude Code session — with sudo askpass helper or direct.

        Always runs inside bash so that when claude exits, the shell
        stays alive and the tab doesn't auto-close.
        """
        flags = []
        if config.get("resume"):
            flags.append("--resume")
        if config.get("skip_permissions"):
            flags.append("--dangerously-skip-permissions")

        prompt = config.get("prompt", "")
        prompt_arg = ""
        if prompt:
            escaped = prompt.replace("'", "'\\''")
            prompt_arg = f" '{escaped}'"

        flags_str = " ".join(flags)

        if config.get("sudo"):
            script = (
                'set -euo pipefail\n'
                'read -rsp "Podaj hasło sudo: " SUDO_PW\n'
                'echo\n'
                'ASKPASS=$(mktemp /tmp/claude-askpass.XXXXXX)\n'
                'chmod 700 "$ASKPASS"\n'
                'cat > "$ASKPASS" <<ASKEOF\n'
                '#!/bin/bash\n'
                'echo \'$SUDO_PW\'\n'
                'ASKEOF\n'
                'export SUDO_ASKPASS="$ASKPASS"\n'
                'if ! sudo -A true 2>/dev/null; then\n'
                '  rm -f "$ASKPASS"\n'
                '  echo "Błędne hasło sudo."\n'
                '  read -p "Naciśnij Enter..."\n'
                '  exit 1\n'
                'fi\n'
                'unset SUDO_PW\n'
                'trap \'rm -f "$ASKPASS"\' EXIT\n'
                f'{CLAUDE_PATH} {flags_str}{prompt_arg}\n'
                'exec bash\n'
            )
        else:
            script = f'{CLAUDE_PATH} {flags_str}{prompt_arg}\nexec bash\n'

        work_dir = config.get("project_dir") or os.environ.get("HOME", "/")
        self.terminal.spawn_async(
            Vte.PtyFlags.DEFAULT,
            work_dir,
            ["/bin/bash", "-c", script],
            None,
            GLib.SpawnFlags.DEFAULT,
            None,
            None,
            -1,
            None,
            None,
        )

    def run_macro(self, macro):
        """Execute macro steps chained via GLib.timeout_add."""
        steps = macro.get("steps", [])
        if not steps:
            return

        def execute_steps(step_index):
            if step_index >= len(steps):
                return False
            step = steps[step_index]
            if step["type"] == "text":
                self.terminal.feed_child(step["value"].encode())
                GLib.timeout_add(50, execute_steps, step_index + 1)
            elif step["type"] == "key":
                key_str = KEY_MAP.get(step["value"], "")
                if key_str:
                    self.terminal.feed_child(key_str.encode())
                GLib.timeout_add(50, execute_steps, step_index + 1)
            elif step["type"] == "delay":
                GLib.timeout_add(int(step["value"]), execute_steps, step_index + 1)
            return False

        GLib.timeout_add(500, execute_steps, 0)

    def _on_key_press(self, terminal, event):
        mod = event.state & Gtk.accelerator_get_default_mod_mask()
        ctrl = Gdk.ModifierType.CONTROL_MASK
        shift = Gdk.ModifierType.SHIFT_MASK

        # Ctrl+Shift+C: copy
        if mod == (ctrl | shift) and event.keyval in (Gdk.KEY_C, Gdk.KEY_c):
            if terminal.get_has_selection():
                terminal.copy_clipboard_format(Vte.Format.TEXT)
            return True

        # Ctrl+Shift+V: paste
        if mod == (ctrl | shift) and event.keyval in (Gdk.KEY_V, Gdk.KEY_v):
            terminal.paste_clipboard()
            return True

        # Ctrl+T: new tab (forward to app)
        if mod == ctrl and event.keyval == Gdk.KEY_t:
            self.app.add_local_tab()
            return True

        # Ctrl+Shift+W: close tab
        if mod == (ctrl | shift) and event.keyval in (Gdk.KEY_W, Gdk.KEY_w):
            self.app.close_tab(self)
            return True

        # Ctrl+PageUp/PageDown: switch tabs
        if mod == ctrl and event.keyval == Gdk.KEY_Page_Up:
            idx = self.app.notebook.get_current_page()
            if idx > 0:
                self.app.notebook.set_current_page(idx - 1)
            return True
        if mod == ctrl and event.keyval == Gdk.KEY_Page_Down:
            idx = self.app.notebook.get_current_page()
            if idx < self.app.notebook.get_n_pages() - 1:
                self.app.notebook.set_current_page(idx + 1)
            return True

        return False

    def _on_button_press(self, terminal, event):
        if event.button == 3:  # right click
            menu = Gtk.Menu()

            item_copy = Gtk.MenuItem(label="Copy")
            item_copy.set_sensitive(terminal.get_has_selection())
            item_copy.connect("activate", lambda _: terminal.copy_clipboard_format(Vte.Format.TEXT))
            menu.append(item_copy)

            item_paste = Gtk.MenuItem(label="Paste")
            item_paste.connect("activate", lambda _: terminal.paste_clipboard())
            menu.append(item_paste)

            menu.append(Gtk.SeparatorMenuItem())

            item_select_all = Gtk.MenuItem(label="Select All")
            item_select_all.connect("activate", lambda _: terminal.select_all())
            menu.append(item_select_all)

            menu.show_all()
            menu.popup_at_pointer(event)
            return True
        return False

    def _on_child_exited(self, terminal, status):
        self.app.on_tab_child_exited(self)

    def _on_title_changed(self, terminal):
        title = terminal.get_window_title()
        if title:
            if self.session:
                # SSH tab: keep session name, show VTE title in window title only
                self.app.update_tab_title(self, self.session.get("name", "SSH"))
            elif self.claude_config:
                # Claude Code tab: keep config name instead of generic VTE title
                self.app.update_tab_title(self, self.claude_config.get("name", "Claude Code"))
            else:
                self.app.update_tab_title(self, title)

    def get_label(self):
        if self.claude_config:
            return self.claude_config.get("name", "Claude Code")
        if self.session:
            return self.session.get("name", "SSH")
        return "Terminal"


# ─── SessionSidebar ───────────────────────────────────────────────────────────

# TreeStore columns
COL_ICON = 0
COL_NAME = 1
COL_ID = 2
COL_TOOLTIP = 3
COL_COLOR = 4
COL_WEIGHT = 5


class SessionSidebar(Gtk.Box):
    """Panel lewy z listą zapisanych sesji SSH."""

    def __init__(self, app):
        super().__init__(orientation=Gtk.Orientation.VERTICAL)
        self.app = app

        # Header
        header = Gtk.Label(label=f"  {APP_NAME} Sessions")
        header.set_halign(Gtk.Align.START)
        header.get_style_context().add_class("sidebar-header")
        self.pack_start(header, False, False, 0)

        # TreeView
        self.store = Gtk.TreeStore(str, str, str, str, str, int)  # icon, name, id, tooltip, color, weight
        self.tree = Gtk.TreeView(model=self.store)
        self.tree.set_headers_visible(False)
        self.tree.set_tooltip_column(COL_TOOLTIP)
        self.tree.set_activate_on_single_click(False)

        # Renderer
        col = Gtk.TreeViewColumn()

        cell_icon = Gtk.CellRendererText()
        col.pack_start(cell_icon, False)
        col.add_attribute(cell_icon, "text", COL_ICON)

        cell_name = Gtk.CellRendererText()
        cell_name.set_property("ellipsize", Pango.EllipsizeMode.END)
        col.pack_start(cell_name, True)
        col.add_attribute(cell_name, "text", COL_NAME)
        col.add_attribute(cell_name, "foreground", COL_COLOR)
        col.add_attribute(cell_name, "weight", COL_WEIGHT)

        self.tree.append_column(col)

        scrolled = Gtk.ScrolledWindow()
        scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scrolled.add(self.tree)
        self.pack_start(scrolled, True, True, 0)

        # Buttons
        btn_box = Gtk.Box(spacing=4)
        btn_box.set_border_width(6)

        btn_add = Gtk.MenuButton(label="Add \u25BE")
        btn_add.get_style_context().add_class("sidebar-btn")
        add_menu = Gtk.Menu()
        item_session = Gtk.MenuItem(label="SSH Session")
        item_session.connect("activate", lambda _: self._on_add(None))
        add_menu.append(item_session)
        item_terminal = Gtk.MenuItem(label="Local Terminal")
        item_terminal.connect("activate", lambda _: self.app.add_local_tab())
        add_menu.append(item_terminal)
        item_claude = Gtk.MenuItem(label="Claude Code")
        item_claude.connect("activate", lambda _: self._on_add_claude())
        add_menu.append(item_claude)
        add_menu.show_all()
        btn_add.set_popup(add_menu)

        btn_edit = Gtk.Button(label="Edit")
        btn_edit.get_style_context().add_class("sidebar-btn")
        btn_edit.connect("clicked", self._on_edit)

        btn_delete = Gtk.Button(label="Delete")
        btn_delete.get_style_context().add_class("sidebar-btn")
        btn_delete.connect("clicked", self._on_delete)

        btn_box.pack_start(btn_add, True, True, 0)
        btn_box.pack_start(btn_edit, True, True, 0)
        btn_box.pack_start(btn_delete, True, True, 0)
        self.pack_start(btn_box, False, False, 0)

        # Signals
        self.tree.connect("row-activated", self._on_row_activated)
        self.tree.connect("button-press-event", self._on_button_press)

        self.refresh()

    def _append_session(self, parent_iter, session):
        """Add a session node and its macro children to the tree store."""
        tooltip = f"{session.get('username', '')}@{session.get('host', '')}:{session.get('port', 22)}"
        session_iter = self.store.append(parent_iter, [
            "\U0001F5A5",
            session["name"],
            session["id"],
            tooltip,
            session.get("color", SESSION_COLORS[0]),
            Pango.Weight.NORMAL,
        ])
        for macro in session.get("macros", []):
            macro_id = f"macro:{session['id']}:{macro['id']}"
            self.store.append(session_iter, [
                "\u25B6",  # ▶
                macro["name"],
                macro_id,
                f"Macro: {macro['name']}",
                CATPPUCCIN["green"],
                Pango.Weight.NORMAL,
            ])

    def _append_claude_session(self, parent_iter, session):
        """Add a Claude Code session node to the tree store."""
        opts = []
        if session.get("sudo"):
            opts.append("sudo")
        if session.get("resume"):
            opts.append("resume")
        if session.get("skip_permissions"):
            opts.append("skip-perms")
        tooltip = ", ".join(opts) if opts else "Claude Code"
        self.store.append(parent_iter, [
            "\U0001F916",  # 🤖
            session["name"],
            f"claude:{session['id']}",
            tooltip,
            session.get("color", SESSION_COLORS[0]),
            Pango.Weight.NORMAL,
        ])

    def refresh(self):
        self.store.clear()
        sessions = self.app.session_manager.all()

        folders = {}
        ungrouped = []

        for s in sessions:
            folder = s.get("folder", "").strip()
            if folder:
                folders.setdefault(folder, []).append(s)
            else:
                ungrouped.append(s)

        # Grouped sessions
        for folder_name in sorted(folders.keys()):
            parent = self.store.append(None, [
                "\U0001F4C1",  # folder icon
                folder_name,
                "",
                folder_name,
                CATPPUCCIN["subtext1"],
                Pango.Weight.NORMAL,
            ])
            for s in folders[folder_name]:
                self._append_session(parent, s)

        # Ungrouped sessions
        for s in ungrouped:
            self._append_session(None, s)

        # ── Claude Code sessions ──
        claude_sessions = self.app.claude_manager.all()
        if claude_sessions:
            # Visual separator
            self.store.append(None, [
                "",
                "\u2500" * 26,  # ────────────
                "",
                "",
                CATPPUCCIN["surface2"],
                Pango.Weight.NORMAL,
            ])
            # Section header (bold)
            self.store.append(None, [
                "\U0001F916",  # 🤖
                "Claude Code",
                "",
                "Claude Code sessions",
                CATPPUCCIN["mauve"],
                Pango.Weight.BOLD,
            ])

            claude_folders = {}
            claude_ungrouped = []
            for s in claude_sessions:
                folder = s.get("folder", "").strip()
                if folder:
                    claude_folders.setdefault(folder, []).append(s)
                else:
                    claude_ungrouped.append(s)

            for folder_name in sorted(claude_folders.keys()):
                parent = self.store.append(None, [
                    "\U0001F4C1",
                    folder_name,
                    "",
                    folder_name,
                    CATPPUCCIN["subtext1"],
                    Pango.Weight.NORMAL,
                ])
                for s in claude_folders[folder_name]:
                    self._append_claude_session(parent, s)

            for s in claude_ungrouped:
                self._append_claude_session(None, s)

        self.tree.expand_all()

    def _get_selected_session_id(self):
        sel = self.tree.get_selection()
        model, it = sel.get_selected()
        if it is None:
            return None
        col_id = model.get_value(it, COL_ID)
        if col_id and not col_id.startswith("macro:"):
            return col_id
        return None

    def _on_row_activated(self, tree, path, column):
        it = self.store.get_iter(path)
        col_id = self.store.get_value(it, COL_ID)
        if col_id and col_id.startswith("macro:"):
            parts = col_id.split(":", 2)
            self._run_macro(parts[1], parts[2])
        elif col_id and col_id.startswith("claude:"):
            claude_id = col_id[7:]
            config = self.app.claude_manager.get(claude_id)
            if config:
                self.app.open_claude_tab(config)
        elif col_id:
            session = self.app.session_manager.get(col_id)
            if session:
                self.app.open_ssh_tab(session)

    def _on_button_press(self, widget, event):
        if event.button == 3:  # right click
            path_info = self.tree.get_path_at_pos(int(event.x), int(event.y))
            if path_info:
                path = path_info[0]
                self.tree.get_selection().select_path(path)
                it = self.store.get_iter(path)
                col_id = self.store.get_value(it, COL_ID)

                if col_id and col_id.startswith("macro:"):
                    # Macro context menu
                    parts = col_id.split(":", 2)
                    sid, mid = parts[1], parts[2]
                    menu = Gtk.Menu()

                    item_run = Gtk.MenuItem(label="Run")
                    item_run.connect("activate", lambda _, s=sid, m=mid: self._run_macro(s, m))
                    menu.append(item_run)

                    item_edit = Gtk.MenuItem(label="Edit")
                    item_edit.connect("activate", lambda _, s=sid, m=mid: self._edit_macro(s, m))
                    menu.append(item_edit)

                    item_delete = Gtk.MenuItem(label="Delete")
                    item_delete.connect("activate", lambda _, s=sid, m=mid: self._delete_macro(s, m))
                    menu.append(item_delete)

                    menu.show_all()
                    menu.popup_at_pointer(event)

                elif col_id and col_id.startswith("claude:"):
                    # Claude Code session context menu
                    claude_id = col_id[7:]
                    menu = Gtk.Menu()

                    item_connect = Gtk.MenuItem(label="Connect")
                    item_connect.connect("activate", lambda _, cid=claude_id: self._connect_claude(cid))
                    menu.append(item_connect)

                    item_edit = Gtk.MenuItem(label="Edit")
                    item_edit.connect("activate", lambda _, cid=claude_id: self._edit_claude(cid))
                    menu.append(item_edit)

                    item_delete = Gtk.MenuItem(label="Delete")
                    item_delete.connect("activate", lambda _, cid=claude_id: self._delete_claude(cid))
                    menu.append(item_delete)

                    menu.append(Gtk.SeparatorMenuItem())

                    item_ctx = Gtk.MenuItem(label="Edit ctx\u2026")
                    item_ctx.connect("activate", lambda _, cid=claude_id: self._edit_ctx(cid))
                    menu.append(item_ctx)

                    menu.show_all()
                    menu.popup_at_pointer(event)

                elif col_id:
                    # Session context menu
                    session_id = col_id
                    menu = Gtk.Menu()

                    item_connect = Gtk.MenuItem(label="Connect")
                    item_connect.connect("activate", lambda _: self._connect_session(session_id))
                    menu.append(item_connect)

                    item_edit = Gtk.MenuItem(label="Edit")
                    item_edit.connect("activate", lambda _: self._edit_session(session_id))
                    menu.append(item_edit)

                    item_delete = Gtk.MenuItem(label="Delete")
                    item_delete.connect("activate", lambda _: self._delete_session(session_id))
                    menu.append(item_delete)

                    menu.append(Gtk.SeparatorMenuItem())

                    item_add_macro = Gtk.MenuItem(label="Add Macro...")
                    item_add_macro.connect("activate", lambda _: self._add_macro(session_id))
                    menu.append(item_add_macro)

                    menu.show_all()
                    menu.popup_at_pointer(event)
            return True
        return False

    def _connect_session(self, session_id):
        session = self.app.session_manager.get(session_id)
        if session:
            self.app.open_ssh_tab(session)

    def _on_add(self, button):
        dlg = SessionDialog(self.app)
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.OK:
                break
            if dlg.validate():
                self.app.session_manager.add(dlg.get_data())
                self.refresh()
                break
        dlg.destroy()

    def _on_add_claude(self):
        dlg = ClaudeCodeDialog(self.app)
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.OK:
                break
            if dlg.validate():
                data = dlg.get_data()
                data = _run_ctx_wizard_if_needed(dlg, data)
                self.app.claude_manager.add(data)
                self.refresh()
                break
        dlg.destroy()

    def _on_edit(self, button):
        sel = self.tree.get_selection()
        model, it = sel.get_selected()
        if it is None:
            return
        col_id = model.get_value(it, COL_ID)
        if col_id and col_id.startswith("claude:"):
            self._edit_claude(col_id[7:])
        elif col_id and not col_id.startswith("macro:"):
            self._edit_session(col_id)

    def _edit_session(self, session_id):
        session = self.app.session_manager.get(session_id)
        if not session:
            return
        dlg = SessionDialog(self.app, session)
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.OK:
                break
            if dlg.validate():
                data = dlg.get_data()
                self.app.session_manager.update(session_id, data)
                self.refresh()
                break
        dlg.destroy()

    def _on_delete(self, button):
        sel = self.tree.get_selection()
        model, it = sel.get_selected()
        if it is None:
            return
        col_id = model.get_value(it, COL_ID)
        if col_id and col_id.startswith("claude:"):
            self._delete_claude(col_id[7:])
        elif col_id and not col_id.startswith("macro:"):
            self._delete_session(col_id)

    def _delete_session(self, session_id):
        session = self.app.session_manager.get(session_id)
        if not session:
            return
        dlg = Gtk.MessageDialog(
            transient_for=self.app,
            modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=f"Delete session \"{session['name']}\"?",
        )
        if dlg.run() == Gtk.ResponseType.YES:
            self.app.session_manager.delete(session_id)
            self.refresh()
        dlg.destroy()

    # ── Macro CRUD ──

    def _add_macro(self, session_id):
        session = self.app.session_manager.get(session_id)
        if not session:
            return
        dlg = MacroDialog(self.app)
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.OK:
                break
            if dlg.validate():
                data = dlg.get_data()
                data["id"] = str(uuid.uuid4())
                session.setdefault("macros", []).append(data)
                self.app.session_manager.save()
                self.refresh()
                break
        dlg.destroy()

    def _edit_macro(self, session_id, macro_id):
        session = self.app.session_manager.get(session_id)
        if not session:
            return
        macro = None
        for m in session.get("macros", []):
            if m["id"] == macro_id:
                macro = m
                break
        if not macro:
            return
        dlg = MacroDialog(self.app, macro)
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.OK:
                break
            if dlg.validate():
                data = dlg.get_data()
                macro.update(data)
                self.app.session_manager.save()
                self.refresh()
                break
        dlg.destroy()

    def _delete_macro(self, session_id, macro_id):
        session = self.app.session_manager.get(session_id)
        if not session:
            return
        macro_name = ""
        for m in session.get("macros", []):
            if m["id"] == macro_id:
                macro_name = m.get("name", "")
                break
        dlg = Gtk.MessageDialog(
            transient_for=self.app,
            modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=f'Delete macro "{macro_name}"?',
        )
        if dlg.run() == Gtk.ResponseType.YES:
            session["macros"] = [
                m for m in session.get("macros", []) if m["id"] != macro_id
            ]
            self.app.session_manager.save()
            self.refresh()
        dlg.destroy()

    def _run_macro(self, session_id, macro_id):
        session = self.app.session_manager.get(session_id)
        if not session:
            return
        macro = None
        for m in session.get("macros", []):
            if m["id"] == macro_id:
                macro = m
                break
        if macro:
            self.app.open_ssh_tab_with_macro(session, macro)

    # ── Claude Code CRUD ──

    def _edit_ctx(self, claude_id):
        config = self.app.claude_manager.get(claude_id)
        if not config:
            return
        project_dir = config.get("project_dir", "")
        if not project_dir:
            return
        ctx_project = os.path.basename(project_dir.rstrip("/"))
        dlg = CtxEditDialog(self.app, ctx_project, project_dir)
        dlg.run()
        dlg.destroy()

    def _connect_claude(self, claude_id):
        config = self.app.claude_manager.get(claude_id)
        if config:
            self.app.open_claude_tab(config)

    def _edit_claude(self, claude_id):
        config = self.app.claude_manager.get(claude_id)
        if not config:
            return
        dlg = ClaudeCodeDialog(self.app, config)
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.OK:
                break
            if dlg.validate():
                data = dlg.get_data()
                data = _run_ctx_wizard_if_needed(dlg, data)
                self.app.claude_manager.update(claude_id, data)
                self.refresh()
                break
        dlg.destroy()

    def _delete_claude(self, claude_id):
        config = self.app.claude_manager.get(claude_id)
        if not config:
            return
        dlg = Gtk.MessageDialog(
            transient_for=self.app,
            modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=f"Delete Claude session \"{config['name']}\"?",
        )
        if dlg.run() == Gtk.ResponseType.YES:
            self.app.claude_manager.delete(claude_id)
            # Ask about ctx cleanup
            project_dir = config.get("project_dir", "")
            if project_dir:
                ctx_name = os.path.basename(project_dir.rstrip("/"))
                if _is_ctx_available() and _is_ctx_project_registered(ctx_name):
                    ctx_dlg = Gtk.MessageDialog(
                        transient_for=self.app,
                        modal=True,
                        message_type=Gtk.MessageType.QUESTION,
                        buttons=Gtk.ButtonsType.YES_NO,
                        text=f"Also delete ctx project \"{ctx_name}\"?",
                    )
                    ctx_dlg.format_secondary_text(
                        "This will remove all context entries for this project from the ctx database."
                    )
                    if ctx_dlg.run() == Gtk.ResponseType.YES:
                        subprocess.run(
                            ["ctx", "delete", ctx_name],
                            capture_output=True, text=True,
                        )
                    ctx_dlg.destroy()
            self.refresh()
        dlg.destroy()


# ─── Ctx Import / Export ──────────────────────────────────────────────────────


class _CtxExportDialog(Gtk.Dialog):
    """Dialog for selectively exporting ctx data to a JSON file."""

    def __init__(self, parent):
        super().__init__(
            title="Export Context",
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            "Export", Gtk.ResponseType.OK,
        )
        self.set_default_size(500, 450)
        self.set_default_response(Gtk.ResponseType.OK)

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(8)

        # Select all / Deselect all
        sel_box = Gtk.Box(spacing=8)
        btn_all = Gtk.Button(label="Select All")
        btn_all.connect("clicked", lambda _: self._set_all(True))
        btn_none = Gtk.Button(label="Deselect All")
        btn_none.connect("clicked", lambda _: self._set_all(False))
        sel_box.pack_start(btn_all, False, False, 0)
        sel_box.pack_start(btn_none, False, False, 0)
        box.pack_start(sel_box, False, False, 0)

        # Tree with checkboxes: toggle, icon, name, data_type, data_key
        self.store = Gtk.TreeStore(bool, str, str, str, str)
        self.tree = Gtk.TreeView(model=self.store)
        self.tree.set_headers_visible(False)

        col = Gtk.TreeViewColumn()
        cell_toggle = Gtk.CellRendererToggle()
        cell_toggle.connect("toggled", self._on_toggled)
        col.pack_start(cell_toggle, False)
        col.add_attribute(cell_toggle, "active", 0)

        cell_icon = Gtk.CellRendererText()
        col.pack_start(cell_icon, False)
        col.add_attribute(cell_icon, "text", 1)

        cell_name = Gtk.CellRendererText()
        cell_name.set_property("ellipsize", Pango.EllipsizeMode.END)
        col.pack_start(cell_name, True)
        col.add_attribute(cell_name, "text", 2)

        self.tree.append_column(col)

        scroll = Gtk.ScrolledWindow()
        scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scroll.add(self.tree)
        box.pack_start(scroll, True, True, 0)

        self._load_data()
        self.show_all()

    def _load_data(self):
        import sqlite3
        if not os.path.exists(CTX_DB):
            return
        db = sqlite3.connect(CTX_DB)
        db.row_factory = sqlite3.Row

        projects = db.execute(
            "SELECT name FROM sessions ORDER BY name"
        ).fetchall()
        for proj in projects:
            pname = proj["name"]
            proj_iter = self.store.append(None, [
                True, "\U0001f4c1", pname, "project", pname,
            ])
            entries = db.execute(
                "SELECT key FROM contexts WHERE project = ? ORDER BY key",
                (pname,),
            ).fetchall()
            for entry in entries:
                self.store.append(proj_iter, [
                    True, " ", entry["key"], "entry", entry["key"],
                ])
            scount = db.execute(
                "SELECT COUNT(*) as c FROM summaries WHERE project = ?",
                (pname,),
            ).fetchone()["c"]
            if scount:
                self.store.append(proj_iter, [
                    True, "\U0001f4cb", f"Summaries ({scount})", "summaries", pname,
                ])

        shared = db.execute("SELECT key FROM shared ORDER BY key").fetchall()
        if shared:
            shared_iter = self.store.append(None, [
                True, "\U0001f517", "Shared", "shared", "",
            ])
            for entry in shared:
                self.store.append(shared_iter, [
                    True, " ", entry["key"], "shared_entry", entry["key"],
                ])

        db.close()
        self.tree.expand_all()

    def _on_toggled(self, renderer, path):
        it = self.store.get_iter(path)
        new_val = not self.store.get_value(it, 0)
        self.store.set_value(it, 0, new_val)
        # Propagate to children
        child = self.store.iter_children(it)
        while child:
            self.store.set_value(child, 0, new_val)
            child = self.store.iter_next(child)
        # Update parent based on children
        parent = self.store.iter_parent(it)
        if parent:
            any_checked = False
            child = self.store.iter_children(parent)
            while child:
                if self.store.get_value(child, 0):
                    any_checked = True
                    break
                child = self.store.iter_next(child)
            self.store.set_value(parent, 0, any_checked)

    def _set_all(self, val):
        def _walk(it):
            while it:
                self.store.set_value(it, 0, val)
                child = self.store.iter_children(it)
                if child:
                    _walk(child)
                it = self.store.iter_next(it)
        root = self.store.get_iter_first()
        if root:
            _walk(root)

    def get_export_data(self):
        """Collect checked items and return export dict."""
        import sqlite3
        if not os.path.exists(CTX_DB):
            return None
        db = sqlite3.connect(CTX_DB)
        db.row_factory = sqlite3.Row
        data = {"sessions": [], "contexts": [], "shared": [], "summaries": []}

        root = self.store.get_iter_first()
        while root:
            dtype = self.store.get_value(root, 3)
            dkey = self.store.get_value(root, 4)

            if dtype == "project":
                proj_name = dkey
                child = self.store.iter_children(root)
                checked_entries = []
                include_summaries = False
                while child:
                    if self.store.get_value(child, 0):
                        ctype = self.store.get_value(child, 3)
                        ckey = self.store.get_value(child, 4)
                        if ctype == "entry":
                            checked_entries.append(ckey)
                        elif ctype == "summaries":
                            include_summaries = True
                    child = self.store.iter_next(child)

                if checked_entries or include_summaries or self.store.get_value(root, 0):
                    row = db.execute(
                        "SELECT * FROM sessions WHERE name = ?", (proj_name,)
                    ).fetchone()
                    if row:
                        data["sessions"].append(dict(row))

                for ekey in checked_entries:
                    row = db.execute(
                        "SELECT project, key, value, updated_at FROM contexts "
                        "WHERE project = ? AND key = ?",
                        (proj_name, ekey),
                    ).fetchone()
                    if row:
                        data["contexts"].append(dict(row))

                if include_summaries:
                    rows = db.execute(
                        "SELECT project, summary, created_at FROM summaries "
                        "WHERE project = ?",
                        (proj_name,),
                    ).fetchall()
                    data["summaries"].extend(dict(r) for r in rows)

            elif dtype == "shared":
                child = self.store.iter_children(root)
                while child:
                    if self.store.get_value(child, 0):
                        skey = self.store.get_value(child, 4)
                        row = db.execute(
                            "SELECT * FROM shared WHERE key = ?", (skey,)
                        ).fetchone()
                        if row:
                            data["shared"].append(dict(row))
                    child = self.store.iter_next(child)

            root = self.store.iter_next(root)
        db.close()

        data = {k: v for k, v in data.items() if v}
        if not data:
            return None
        data["_export_version"] = 1
        return data


class _CtxImportDialog(Gtk.Dialog):
    """Dialog for importing ctx data from a JSON file."""

    def __init__(self, parent):
        super().__init__(
            title="Import Context",
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            "Import", Gtk.ResponseType.OK,
        )
        self.set_default_size(500, 450)
        self.set_default_response(Gtk.ResponseType.OK)
        self.set_response_sensitive(Gtk.ResponseType.OK, False)

        box = self.get_content_area()
        box.set_border_width(12)
        box.set_spacing(8)

        # File chooser
        file_box = Gtk.Box(spacing=8)
        file_box.pack_start(Gtk.Label(label="File:"), False, False, 0)
        self.file_entry = Gtk.Entry(hexpand=True)
        self.file_entry.set_placeholder_text("Select JSON file\u2026")
        self.file_entry.set_editable(False)
        file_box.pack_start(self.file_entry, True, True, 0)
        btn_browse = Gtk.Button(label="Browse\u2026")
        btn_browse.connect("clicked", self._on_browse)
        file_box.pack_start(btn_browse, False, False, 0)
        box.pack_start(file_box, False, False, 0)

        # Select all / Deselect all
        sel_box = Gtk.Box(spacing=8)
        btn_all = Gtk.Button(label="Select All")
        btn_all.connect("clicked", lambda _: self._set_all(True))
        btn_none = Gtk.Button(label="Deselect All")
        btn_none.connect("clicked", lambda _: self._set_all(False))
        sel_box.pack_start(btn_all, False, False, 0)
        sel_box.pack_start(btn_none, False, False, 0)
        box.pack_start(sel_box, False, False, 0)

        # Preview tree: toggle, icon, name, data_type, data_key
        self.store = Gtk.TreeStore(bool, str, str, str, str)
        self.tree = Gtk.TreeView(model=self.store)
        self.tree.set_headers_visible(False)

        col = Gtk.TreeViewColumn()
        cell_toggle = Gtk.CellRendererToggle()
        cell_toggle.connect("toggled", self._on_toggled)
        col.pack_start(cell_toggle, False)
        col.add_attribute(cell_toggle, "active", 0)

        cell_icon = Gtk.CellRendererText()
        col.pack_start(cell_icon, False)
        col.add_attribute(cell_icon, "text", 1)

        cell_name = Gtk.CellRendererText()
        cell_name.set_property("ellipsize", Pango.EllipsizeMode.END)
        col.pack_start(cell_name, True)
        col.add_attribute(cell_name, "text", 2)

        self.tree.append_column(col)

        scroll = Gtk.ScrolledWindow()
        scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scroll.add(self.tree)
        box.pack_start(scroll, True, True, 0)

        # Overwrite option
        self.chk_overwrite = Gtk.CheckButton(label="Overwrite existing entries")
        box.pack_start(self.chk_overwrite, False, False, 0)

        self.import_data = None
        self.show_all()

    def _on_browse(self, button):
        dlg = Gtk.FileChooserDialog(
            title="Select context file",
            parent=self,
            action=Gtk.FileChooserAction.OPEN,
        )
        dlg.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OPEN, Gtk.ResponseType.OK,
        )
        filt = Gtk.FileFilter()
        filt.set_name("JSON files")
        filt.add_pattern("*.json")
        dlg.add_filter(filt)
        filt_all = Gtk.FileFilter()
        filt_all.set_name("All files")
        filt_all.add_pattern("*")
        dlg.add_filter(filt_all)
        if dlg.run() == Gtk.ResponseType.OK:
            path = dlg.get_filename()
            self.file_entry.set_text(path)
            self._load_preview(path)
        dlg.destroy()

    def _load_preview(self, path):
        self.store.clear()
        self.import_data = None
        self.set_response_sensitive(Gtk.ResponseType.OK, False)
        try:
            with open(path, "r") as f:
                data = json.load(f)
        except (json.JSONDecodeError, OSError) as e:
            dlg = Gtk.MessageDialog(
                transient_for=self,
                modal=True,
                message_type=Gtk.MessageType.ERROR,
                buttons=Gtk.ButtonsType.OK,
                text=f"Failed to load file: {e}",
            )
            dlg.run()
            dlg.destroy()
            return

        self.import_data = data

        # Group by project
        sessions = {s["name"]: s for s in data.get("sessions", [])}
        contexts_by_proj = {}
        for ctx in data.get("contexts", []):
            contexts_by_proj.setdefault(ctx["project"], []).append(ctx)
        summaries_by_proj = {}
        for s in data.get("summaries", []):
            summaries_by_proj.setdefault(s["project"], []).append(s)

        all_projects = sorted(
            set(sessions) | set(contexts_by_proj) | set(summaries_by_proj)
        )
        for proj_name in all_projects:
            proj_iter = self.store.append(None, [
                True, "\U0001f4c1", proj_name, "project", proj_name,
            ])
            for ctx in contexts_by_proj.get(proj_name, []):
                self.store.append(proj_iter, [
                    True, " ", ctx["key"], "entry", ctx["key"],
                ])
            scount = len(summaries_by_proj.get(proj_name, []))
            if scount:
                self.store.append(proj_iter, [
                    True, "\U0001f4cb", f"Summaries ({scount})", "summaries", proj_name,
                ])

        shared = data.get("shared", [])
        if shared:
            shared_iter = self.store.append(None, [
                True, "\U0001f517", "Shared", "shared", "",
            ])
            for entry in shared:
                self.store.append(shared_iter, [
                    True, " ", entry["key"], "shared_entry", entry["key"],
                ])

        self.tree.expand_all()
        self.set_response_sensitive(Gtk.ResponseType.OK, True)

    def _on_toggled(self, renderer, path):
        it = self.store.get_iter(path)
        new_val = not self.store.get_value(it, 0)
        self.store.set_value(it, 0, new_val)
        child = self.store.iter_children(it)
        while child:
            self.store.set_value(child, 0, new_val)
            child = self.store.iter_next(child)
        parent = self.store.iter_parent(it)
        if parent:
            any_checked = False
            child = self.store.iter_children(parent)
            while child:
                if self.store.get_value(child, 0):
                    any_checked = True
                    break
                child = self.store.iter_next(child)
            self.store.set_value(parent, 0, any_checked)

    def _set_all(self, val):
        def _walk(it):
            while it:
                self.store.set_value(it, 0, val)
                child = self.store.iter_children(it)
                if child:
                    _walk(child)
                it = self.store.iter_next(it)
        root = self.store.get_iter_first()
        if root:
            _walk(root)

    def get_selected_data(self):
        """Return (filtered_data_dict, overwrite_bool) or (None, False)."""
        if not self.import_data:
            return None, False

        data = self.import_data
        overwrite = self.chk_overwrite.get_active()
        sessions_map = {s["name"]: s for s in data.get("sessions", [])}
        contexts_by_proj = {}
        for ctx in data.get("contexts", []):
            contexts_by_proj.setdefault(ctx["project"], []).append(ctx)
        summaries_by_proj = {}
        for s in data.get("summaries", []):
            summaries_by_proj.setdefault(s["project"], []).append(s)
        shared_map = {s["key"]: s for s in data.get("shared", [])}

        result = {"sessions": [], "contexts": [], "shared": [], "summaries": []}

        root = self.store.get_iter_first()
        while root:
            dtype = self.store.get_value(root, 3)
            dkey = self.store.get_value(root, 4)

            if dtype == "project":
                proj_name = dkey
                child = self.store.iter_children(root)
                checked_entries = []
                include_summaries = False
                while child:
                    if self.store.get_value(child, 0):
                        ctype = self.store.get_value(child, 3)
                        ckey = self.store.get_value(child, 4)
                        if ctype == "entry":
                            checked_entries.append(ckey)
                        elif ctype == "summaries":
                            include_summaries = True
                    child = self.store.iter_next(child)

                if checked_entries or include_summaries:
                    if proj_name in sessions_map:
                        result["sessions"].append(sessions_map[proj_name])
                    for ekey in checked_entries:
                        for ctx in contexts_by_proj.get(proj_name, []):
                            if ctx["key"] == ekey:
                                result["contexts"].append(ctx)
                                break
                    if include_summaries:
                        result["summaries"].extend(
                            summaries_by_proj.get(proj_name, [])
                        )

            elif dtype == "shared":
                child = self.store.iter_children(root)
                while child:
                    if self.store.get_value(child, 0):
                        skey = self.store.get_value(child, 4)
                        if skey in shared_map:
                            result["shared"].append(shared_map[skey])
                    child = self.store.iter_next(child)

            root = self.store.iter_next(root)

        result = {k: v for k, v in result.items() if v}
        return (result if result else None), overwrite


# ─── CtxManagerPanel ──────────────────────────────────────────────────────────


class CtxManagerPanel(Gtk.Box):
    """Panel for browsing and managing ctx project contexts."""

    def __init__(self, app):
        super().__init__(orientation=Gtk.Orientation.VERTICAL)
        self.app = app

        # Paned: tree on top, detail on bottom
        paned = Gtk.VPaned()
        self.pack_start(paned, True, True, 0)

        # ── Tree ──
        # Columns: icon, display_name, project, key, color, weight
        self.store = Gtk.TreeStore(str, str, str, str, str, int)
        self.tree = Gtk.TreeView(model=self.store)
        self.tree.set_headers_visible(False)
        self.tree.set_activate_on_single_click(False)

        col = Gtk.TreeViewColumn()
        cell_icon = Gtk.CellRendererText()
        col.pack_start(cell_icon, False)
        col.add_attribute(cell_icon, "text", 0)

        cell_name = Gtk.CellRendererText()
        cell_name.set_property("ellipsize", Pango.EllipsizeMode.END)
        col.pack_start(cell_name, True)
        col.add_attribute(cell_name, "text", 1)
        col.add_attribute(cell_name, "foreground", 4)
        col.add_attribute(cell_name, "weight", 5)

        self.tree.append_column(col)

        tree_scroll = Gtk.ScrolledWindow()
        tree_scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        tree_scroll.add(self.tree)
        paned.pack1(tree_scroll, resize=True, shrink=False)

        # ── Detail pane ──
        detail_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        self.detail_header = Gtk.Label(xalign=0)
        self.detail_header.set_margin_start(8)
        self.detail_header.set_margin_top(4)
        detail_box.pack_start(self.detail_header, False, False, 0)

        detail_scroll = Gtk.ScrolledWindow()
        detail_scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        detail_scroll.set_min_content_height(80)
        self.detail_view = Gtk.TextView()
        self.detail_view.set_editable(False)
        self.detail_view.set_cursor_visible(False)
        self.detail_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        self.detail_view.set_left_margin(8)
        self.detail_view.set_right_margin(8)
        self.detail_view.set_top_margin(4)
        self.detail_view.set_bottom_margin(4)
        self.detail_view.get_style_context().add_class("ctx-detail")
        detail_scroll.add(self.detail_view)
        detail_box.pack_start(detail_scroll, True, True, 0)

        paned.pack2(detail_box, resize=False, shrink=False)
        paned.set_position(300)

        # ── Buttons ──
        btn_box = Gtk.Box(spacing=4)
        btn_box.set_border_width(6)

        btn_add = Gtk.MenuButton(label="Add \u25be")
        btn_add.get_style_context().add_class("sidebar-btn")
        add_menu = Gtk.Menu()
        item_proj = Gtk.MenuItem(label="New Project")
        item_proj.connect("activate", lambda _: self._on_add_project())
        add_menu.append(item_proj)
        item_entry = Gtk.MenuItem(label="New Entry")
        item_entry.connect("activate", lambda _: self._on_add_entry())
        add_menu.append(item_entry)
        add_menu.show_all()
        btn_add.set_popup(add_menu)

        btn_edit = Gtk.Button(label="Edit")
        btn_edit.get_style_context().add_class("sidebar-btn")
        btn_edit.connect("clicked", lambda _: self._on_edit())

        btn_del = Gtk.Button(label="Delete")
        btn_del.get_style_context().add_class("sidebar-btn")
        btn_del.connect("clicked", lambda _: self._on_delete())

        btn_refresh = Gtk.Button(label="\u21bb")
        btn_refresh.get_style_context().add_class("sidebar-btn")
        btn_refresh.set_tooltip_text("Refresh")
        btn_refresh.connect("clicked", lambda _: self.refresh())

        btn_more = Gtk.MenuButton(label="\u22ee")
        btn_more.get_style_context().add_class("sidebar-btn")
        btn_more.set_tooltip_text("More actions")
        more_menu = Gtk.Menu()
        item_export = Gtk.MenuItem(label="Export\u2026")
        item_export.connect("activate", lambda _: self._on_export())
        more_menu.append(item_export)
        item_import = Gtk.MenuItem(label="Import\u2026")
        item_import.connect("activate", lambda _: self._on_import())
        more_menu.append(item_import)
        more_menu.show_all()
        btn_more.set_popup(more_menu)

        btn_box.pack_start(btn_add, True, True, 0)
        btn_box.pack_start(btn_edit, True, True, 0)
        btn_box.pack_start(btn_del, True, True, 0)
        btn_box.pack_start(btn_refresh, False, False, 0)
        btn_box.pack_start(btn_more, False, False, 0)
        self.pack_start(btn_box, False, False, 0)

        # Signals
        self.tree.connect("row-activated", self._on_row_activated)
        self.tree.connect("button-press-event", self._on_button_press)
        self.tree.get_selection().connect("changed", self._on_selection_changed)

        self.refresh()

    def refresh(self):
        """Reload all data from the ctx database."""
        self.store.clear()
        self.detail_header.set_text("")
        self.detail_view.get_buffer().set_text("")
        if not os.path.exists(CTX_DB):
            return

        import sqlite3
        db = sqlite3.connect(CTX_DB)
        db.row_factory = sqlite3.Row

        projects = db.execute(
            "SELECT name, description, work_dir FROM sessions ORDER BY name"
        ).fetchall()

        for proj in projects:
            proj_iter = self.store.append(None, [
                "\U0001f4c1",
                proj["name"],
                proj["name"],
                "",
                CATPPUCCIN["blue"],
                Pango.Weight.BOLD,
            ])
            entries = db.execute(
                "SELECT key FROM contexts WHERE project = ? ORDER BY key",
                (proj["name"],),
            ).fetchall()
            for entry in entries:
                self.store.append(proj_iter, [
                    " ",
                    entry["key"],
                    proj["name"],
                    entry["key"],
                    CATPPUCCIN["text"],
                    Pango.Weight.NORMAL,
                ])

        # Shared entries
        shared = db.execute("SELECT key FROM shared ORDER BY key").fetchall()
        if shared:
            shared_iter = self.store.append(None, [
                "\U0001f517",
                "Shared",
                "__shared__",
                "",
                CATPPUCCIN["peach"],
                Pango.Weight.BOLD,
            ])
            for entry in shared:
                self.store.append(shared_iter, [
                    " ",
                    entry["key"],
                    "__shared__",
                    entry["key"],
                    CATPPUCCIN["text"],
                    Pango.Weight.NORMAL,
                ])

        db.close()
        self.tree.expand_all()

    def _get_selected_info(self):
        """Returns (project_name, entry_key) of selected row."""
        sel = self.tree.get_selection()
        model, it = sel.get_selected()
        if it is None:
            return None, None
        return model.get_value(it, 2), model.get_value(it, 3)

    def _on_selection_changed(self, selection):
        model, it = selection.get_selected()
        if it is None:
            self.detail_header.set_text("")
            self.detail_view.get_buffer().set_text("")
            return
        project = model.get_value(it, 2)
        key = model.get_value(it, 3)
        if key:
            self._show_entry_detail(project, key)
        else:
            self._show_project_detail(project)

    def _show_project_detail(self, project):
        import sqlite3
        if not os.path.exists(CTX_DB):
            return
        db = sqlite3.connect(CTX_DB)
        db.row_factory = sqlite3.Row

        if project == "__shared__":
            self.detail_header.set_markup("<b>\U0001f517 Shared</b>")
            self.detail_view.get_buffer().set_text(
                "Shared context entries available to all projects."
            )
            db.close()
            return

        proj = db.execute(
            "SELECT description, work_dir FROM sessions WHERE name = ?",
            (project,),
        ).fetchone()
        if not proj:
            db.close()
            return

        self.detail_header.set_markup(
            f"<b>\U0001f4c1 {GLib.markup_escape_text(project)}</b>"
        )
        lines = []
        if proj["description"]:
            lines.append(proj["description"])
        if proj["work_dir"]:
            lines.append(f"Dir: {proj['work_dir']}")

        count = db.execute(
            "SELECT COUNT(*) FROM contexts WHERE project = ?", (project,)
        ).fetchone()[0]
        lines.append(f"Entries: {count}")

        # Last summary
        summary = db.execute(
            "SELECT summary, created_at FROM summaries "
            "WHERE project = ? ORDER BY created_at DESC LIMIT 1",
            (project,),
        ).fetchone()
        if summary:
            lines.append(
                f"\n\u2500\u2500 Last summary ({summary['created_at'][:10]}) \u2500\u2500"
            )
            lines.append(summary["summary"])

        # Associated Claude session prompt
        for cs in self.app.claude_manager.all():
            cs_dir = cs.get("project_dir", "").rstrip("/")
            if cs_dir and os.path.basename(cs_dir) == project:
                prompt = cs.get("prompt", "")
                if prompt:
                    lines.append("\n\u2500\u2500 Introductory prompt \u2500\u2500")
                    lines.append(prompt)
                break

        self.detail_view.get_buffer().set_text("\n".join(lines))
        db.close()

    def _show_entry_detail(self, project, key):
        import sqlite3
        if not os.path.exists(CTX_DB):
            return
        db = sqlite3.connect(CTX_DB)
        if project == "__shared__":
            row = db.execute(
                "SELECT value FROM shared WHERE key = ?", (key,)
            ).fetchone()
        else:
            row = db.execute(
                "SELECT value FROM contexts WHERE project = ? AND key = ?",
                (project, key),
            ).fetchone()
        if row:
            self.detail_header.set_markup(
                f"<b>{GLib.markup_escape_text(key)}</b>"
            )
            self.detail_view.get_buffer().set_text(row[0])
        db.close()

    def _on_row_activated(self, tree, path, column):
        self._on_edit()

    def _on_button_press(self, widget, event):
        if event.button != 3:
            return False
        path_info = self.tree.get_path_at_pos(int(event.x), int(event.y))
        if not path_info:
            return True
        path = path_info[0]
        self.tree.get_selection().select_path(path)
        it = self.store.get_iter(path)
        project = self.store.get_value(it, 2)
        key = self.store.get_value(it, 3)

        menu = Gtk.Menu()
        if not key:
            # Project row
            item_add = Gtk.MenuItem(label="Add Entry")
            item_add.connect("activate", lambda _: self._on_add_entry())
            menu.append(item_add)

            item_edit = Gtk.MenuItem(label="Edit Project")
            item_edit.connect("activate", lambda _: self._on_edit())
            menu.append(item_edit)

            menu.append(Gtk.SeparatorMenuItem())

            item_del = Gtk.MenuItem(label="Delete Project")
            item_del.connect("activate", lambda _: self._on_delete())
            menu.append(item_del)
        else:
            # Entry row
            item_edit = Gtk.MenuItem(label="Edit Entry")
            item_edit.connect("activate", lambda _: self._on_edit())
            menu.append(item_edit)

            item_del = Gtk.MenuItem(label="Delete Entry")
            item_del.connect("activate", lambda _: self._on_delete())
            menu.append(item_del)

        menu.show_all()
        menu.popup_at_pointer(event)
        return True

    def _on_add_project(self):
        dlg = _CtxProjectDialog(self.app, "New Project")
        if dlg.run() == Gtk.ResponseType.OK:
            name, desc, work_dir = dlg.get_data()
            if name and desc:
                args = ["ctx", "init", name, desc]
                if work_dir:
                    args.append(work_dir)
                subprocess.run(args, capture_output=True, text=True)
                self.refresh()
        dlg.destroy()

    def _on_add_entry(self):
        project, _ = self._get_selected_info()
        if not project or project == "__shared__":
            return
        dlg = _CtxEntryDialog(self.app, f"Add entry to {project}")
        if dlg.run() == Gtk.ResponseType.OK:
            key, value = dlg.get_data()
            if key:
                subprocess.run(
                    ["ctx", "set", project, key, value],
                    capture_output=True, text=True,
                )
                self.refresh()
        dlg.destroy()

    def _on_edit(self):
        project, key = self._get_selected_info()
        if not project:
            return
        if project == "__shared__":
            if key:
                self._edit_shared_entry(key)
            return
        if key:
            self._edit_entry(project, key)
        else:
            self._edit_project(project)

    def _edit_project(self, project):
        import sqlite3
        if not os.path.exists(CTX_DB):
            return
        db = sqlite3.connect(CTX_DB)
        row = db.execute(
            "SELECT description, work_dir FROM sessions WHERE name = ?",
            (project,),
        ).fetchone()
        db.close()
        if not row:
            return
        dlg = _CtxProjectDialog(
            self.app, "Edit Project", project, row[0] or "", row[1] or ""
        )
        dlg.entry_name.set_sensitive(False)
        if dlg.run() == Gtk.ResponseType.OK:
            _, desc, work_dir = dlg.get_data()
            if desc:
                args = ["ctx", "init", project, desc]
                if work_dir:
                    args.append(work_dir)
                subprocess.run(args, capture_output=True, text=True)
                self.refresh()
        dlg.destroy()

    def _edit_entry(self, project, key):
        import sqlite3
        if not os.path.exists(CTX_DB):
            return
        db = sqlite3.connect(CTX_DB)
        row = db.execute(
            "SELECT value FROM contexts WHERE project = ? AND key = ?",
            (project, key),
        ).fetchone()
        db.close()
        if not row:
            return
        dlg = _CtxEntryDialog(self.app, f"Edit: {key}", key, row[0])
        if dlg.run() == Gtk.ResponseType.OK:
            new_key, value = dlg.get_data()
            if new_key:
                if new_key != key:
                    subprocess.run(
                        ["ctx", "delete", project, key],
                        capture_output=True, text=True,
                    )
                subprocess.run(
                    ["ctx", "set", project, new_key, value],
                    capture_output=True, text=True,
                )
                self.refresh()
        dlg.destroy()

    def _edit_shared_entry(self, key):
        import sqlite3
        if not os.path.exists(CTX_DB):
            return
        db = sqlite3.connect(CTX_DB)
        row = db.execute(
            "SELECT value FROM shared WHERE key = ?", (key,)
        ).fetchone()
        db.close()
        if not row:
            return
        dlg = _CtxEntryDialog(self.app, f"Edit shared: {key}", key, row[0])
        if dlg.run() == Gtk.ResponseType.OK:
            new_key, value = dlg.get_data()
            if new_key:
                db = sqlite3.connect(CTX_DB)
                if new_key != key:
                    db.execute("DELETE FROM shared WHERE key = ?", (key,))
                db.execute(
                    "INSERT OR REPLACE INTO shared (key, value, updated_at) "
                    "VALUES (?, ?, datetime('now'))",
                    (new_key, value),
                )
                db.commit()
                db.close()
                self.refresh()
        dlg.destroy()

    def _on_delete(self):
        project, key = self._get_selected_info()
        if not project:
            return
        if key:
            self._delete_entry(project, key)
        elif project != "__shared__":
            self._delete_project(project)

    def _delete_entry(self, project, key):
        dlg = Gtk.MessageDialog(
            transient_for=self.app,
            modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=f'Delete entry "{key}" from {project}?',
        )
        if dlg.run() == Gtk.ResponseType.YES:
            if project == "__shared__":
                import sqlite3
                db = sqlite3.connect(CTX_DB)
                db.execute("DELETE FROM shared WHERE key = ?", (key,))
                db.commit()
                db.close()
            else:
                subprocess.run(
                    ["ctx", "delete", project, key],
                    capture_output=True, text=True,
                )
            self.refresh()
        dlg.destroy()

    def _delete_project(self, project):
        dlg = Gtk.MessageDialog(
            transient_for=self.app,
            modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=f'Delete project "{project}" and all its entries?',
        )
        if dlg.run() == Gtk.ResponseType.YES:
            subprocess.run(
                ["ctx", "delete", project],
                capture_output=True, text=True,
            )
            self.refresh()
        dlg.destroy()

    def _on_export(self):
        dlg = _CtxExportDialog(self.app)
        if dlg.run() == Gtk.ResponseType.OK:
            data = dlg.get_export_data()
            if data:
                save_dlg = Gtk.FileChooserDialog(
                    title="Save export file",
                    parent=self.app,
                    action=Gtk.FileChooserAction.SAVE,
                )
                save_dlg.add_buttons(
                    Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
                    Gtk.STOCK_SAVE, Gtk.ResponseType.OK,
                )
                save_dlg.set_do_overwrite_confirmation(True)
                save_dlg.set_current_name("ctx_export.json")
                filt = Gtk.FileFilter()
                filt.set_name("JSON files")
                filt.add_pattern("*.json")
                save_dlg.add_filter(filt)
                if save_dlg.run() == Gtk.ResponseType.OK:
                    path = save_dlg.get_filename()
                    try:
                        with open(path, "w") as f:
                            json.dump(data, f, indent=2, ensure_ascii=False)
                    except OSError as e:
                        err = Gtk.MessageDialog(
                            transient_for=self.app,
                            modal=True,
                            message_type=Gtk.MessageType.ERROR,
                            buttons=Gtk.ButtonsType.OK,
                            text=f"Failed to save: {e}",
                        )
                        err.run()
                        err.destroy()
                save_dlg.destroy()
        dlg.destroy()

    def _on_import(self):
        dlg = _CtxImportDialog(self.app)
        if dlg.run() == Gtk.ResponseType.OK:
            data, overwrite = dlg.get_selected_data()
            if data:
                self._do_import(data, overwrite)
                self.refresh()
        dlg.destroy()

    def _do_import(self, data, overwrite):
        import sqlite3
        # Ensure database and tables exist
        subprocess.run(["ctx", "list"], capture_output=True, text=True)
        if not os.path.exists(CTX_DB):
            return

        db = sqlite3.connect(CTX_DB)
        mode = "REPLACE" if overwrite else "IGNORE"

        for session in data.get("sessions", []):
            db.execute(
                f"INSERT OR {mode} INTO sessions (name, description, work_dir, created_at) "
                "VALUES (?, ?, ?, ?)",
                (
                    session["name"],
                    session.get("description", ""),
                    session.get("work_dir", ""),
                    session.get("created_at", ""),
                ),
            )

        for ctx in data.get("contexts", []):
            db.execute(
                f"INSERT OR {mode} INTO contexts (project, key, value, updated_at) "
                "VALUES (?, ?, ?, ?)",
                (
                    ctx["project"],
                    ctx["key"],
                    ctx["value"],
                    ctx.get("updated_at", ""),
                ),
            )

        for shared in data.get("shared", []):
            db.execute(
                f"INSERT OR {mode} INTO shared (key, value, updated_at) "
                "VALUES (?, ?, ?)",
                (
                    shared["key"],
                    shared["value"],
                    shared.get("updated_at", ""),
                ),
            )

        for summary in data.get("summaries", []):
            db.execute(
                "INSERT INTO summaries (project, summary, created_at) "
                "VALUES (?, ?, ?)",
                (
                    summary["project"],
                    summary["summary"],
                    summary.get("created_at", ""),
                ),
            )

        db.commit()
        db.close()


# ─── BTerminalApp ─────────────────────────────────────────────────────────────


class BTerminalApp(Gtk.Window):
    """Główne okno aplikacji BTerminal."""

    def __init__(self):
        super().__init__(title=APP_NAME)
        self.set_default_size(1200, 700)
        self.set_icon_name("bterminal")

        # Apply CSS
        css_provider = Gtk.CssProvider()
        css_provider.load_from_data(CSS.encode())
        Gtk.StyleContext.add_provider_for_screen(
            Gdk.Screen.get_default(),
            css_provider,
            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
        )

        # Dark theme
        settings = Gtk.Settings.get_default()
        settings.set_property("gtk-application-prefer-dark-theme", True)

        # Session managers
        self.session_manager = SessionManager()
        self.claude_manager = ClaudeSessionManager()

        # Layout: HPaned
        paned = Gtk.HPaned()
        self.add(paned)

        # Sidebar container with stack switcher
        sidebar_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        sidebar_box.get_style_context().add_class("sidebar")
        sidebar_box.set_size_request(250, -1)

        self.sidebar_stack = Gtk.Stack()
        self.sidebar_stack.set_transition_type(
            Gtk.StackTransitionType.SLIDE_LEFT_RIGHT
        )

        self.sidebar = SessionSidebar(self)
        self.sidebar_stack.add_titled(self.sidebar, "sessions", "Sessions")

        self.ctx_panel = CtxManagerPanel(self)
        self.sidebar_stack.add_titled(self.ctx_panel, "ctx", "Ctx")

        switcher = Gtk.StackSwitcher()
        switcher.set_stack(self.sidebar_stack)
        switcher.set_halign(Gtk.Align.FILL)
        switcher.set_homogeneous(True)

        sidebar_box.pack_start(switcher, False, False, 0)
        sidebar_box.pack_start(self.sidebar_stack, True, True, 0)

        paned.pack1(sidebar_box, resize=False, shrink=False)

        # Notebook (tabs)
        self.notebook = Gtk.Notebook()
        self.notebook.set_scrollable(True)
        self.notebook.set_show_border(False)
        self.notebook.popup_disable()
        paned.pack2(self.notebook, resize=True, shrink=False)

        paned.set_position(250)

        # Auto-refresh ctx panel when switching to it
        self.sidebar_stack.connect(
            "notify::visible-child",
            lambda s, _: (
                self.ctx_panel.refresh()
                if s.get_visible_child() is self.ctx_panel
                else None
            ),
        )

        # Keyboard shortcuts
        self.connect("key-press-event", self._on_key_press)
        self.connect("delete-event", self._on_delete_event)
        self.notebook.connect("switch-page", self._on_switch_page)

        # Open initial local shell
        self.add_local_tab()

        self.show_all()

    def _update_window_title(self):
        """Update window title bar: 'BTerminal — tab_name [n/total]'."""
        n = self.notebook.get_n_pages()
        idx = self.notebook.get_current_page()
        if idx < 0 or n == 0:
            self.set_title(APP_NAME)
            return
        tab = self.notebook.get_nth_page(idx)
        if isinstance(tab, TerminalTab):
            name = tab.get_label()
        else:
            name = "Terminal"
        if n > 1:
            self.set_title(f"{APP_NAME} — {name} [{idx + 1}/{n}]")
        else:
            self.set_title(f"{APP_NAME} — {name}")

    def _on_switch_page(self, notebook, page, page_num):
        GLib.idle_add(self._update_window_title)

    def _build_tab_label(self, text, tab_widget):
        """Build a tab label with a close button."""
        box = Gtk.Box(spacing=4)

        label = Gtk.Label(label=text)
        box.pack_start(label, True, True, 0)

        close_btn = Gtk.Button(label="×")
        close_btn.get_style_context().add_class("tab-close-btn")
        close_btn.set_relief(Gtk.ReliefStyle.NONE)
        close_btn.connect("clicked", lambda _: self.close_tab(tab_widget))
        box.pack_start(close_btn, False, False, 0)

        box.show_all()
        return box

    def add_local_tab(self):
        tab = TerminalTab(self)
        label = self._build_tab_label("Terminal", tab)
        idx = self.notebook.append_page(tab, label)
        self.notebook.set_current_page(idx)
        self.notebook.set_tab_reorderable(tab, True)
        tab.terminal.grab_focus()
        self._update_window_title()

    def open_ssh_tab(self, session):
        tab = TerminalTab(self, session=session)
        name = session.get("name", "SSH")
        label = self._build_tab_label(name, tab)
        idx = self.notebook.append_page(tab, label)
        self.notebook.set_current_page(idx)
        self.notebook.set_tab_reorderable(tab, True)
        tab.terminal.grab_focus()
        self._update_window_title()

    def open_ssh_tab_with_macro(self, session, macro):
        tab = TerminalTab(self, session=session)
        name = f"{session.get('name', 'SSH')} \u2014 {macro.get('name', 'Macro')}"
        label = self._build_tab_label(name, tab)
        idx = self.notebook.append_page(tab, label)
        self.notebook.set_current_page(idx)
        self.notebook.set_tab_reorderable(tab, True)
        tab.terminal.grab_focus()
        tab.run_macro(macro)
        self._update_window_title()

    def open_claude_tab(self, config):
        tab = TerminalTab(self, claude_config=config)
        tab_name = config.get("name", "Claude Code")
        label = self._build_tab_label(tab_name, tab)
        idx = self.notebook.append_page(tab, label)
        self.notebook.set_current_page(idx)
        self.notebook.set_tab_reorderable(tab, True)
        tab.terminal.grab_focus()
        self._update_window_title()

    def close_tab(self, tab):
        idx = self.notebook.page_num(tab)
        if idx >= 0:
            self.notebook.remove_page(idx)
            tab.destroy()
        # If no tabs left, open a new local shell
        if self.notebook.get_n_pages() == 0:
            self.add_local_tab()
        self._update_window_title()

    def on_tab_child_exited(self, tab):
        """Called when a terminal's child process exits."""
        GLib.idle_add(self.close_tab, tab)

    def update_tab_title(self, tab, title):
        """Update tab label when terminal title changes."""
        idx = self.notebook.page_num(tab)
        if idx >= 0:
            label_widget = self._build_tab_label(title, tab)
            self.notebook.set_tab_label(tab, label_widget)
            self._update_window_title()

    def _get_current_terminal(self):
        idx = self.notebook.get_current_page()
        if idx < 0:
            return None
        tab = self.notebook.get_nth_page(idx)
        if isinstance(tab, TerminalTab):
            return tab.terminal
        return None

    def _on_key_press(self, widget, event):
        mod = event.state & Gtk.accelerator_get_default_mod_mask()
        ctrl = Gdk.ModifierType.CONTROL_MASK
        shift = Gdk.ModifierType.SHIFT_MASK

        # Ctrl+T: new local tab
        if mod == ctrl and event.keyval == Gdk.KEY_t:
            self.add_local_tab()
            return True

        # Ctrl+Shift+W: close current tab
        if mod == (ctrl | shift) and event.keyval in (Gdk.KEY_W, Gdk.KEY_w):
            idx = self.notebook.get_current_page()
            if idx >= 0:
                tab = self.notebook.get_nth_page(idx)
                self.close_tab(tab)
            return True

        # Ctrl+Shift+C: copy
        if mod == (ctrl | shift) and event.keyval in (Gdk.KEY_C, Gdk.KEY_c):
            term = self._get_current_terminal()
            if term:
                term.copy_clipboard_format(Vte.Format.TEXT)
            return True

        # Ctrl+Shift+V: paste
        if mod == (ctrl | shift) and event.keyval in (Gdk.KEY_V, Gdk.KEY_v):
            term = self._get_current_terminal()
            if term:
                term.paste_clipboard()
            return True

        # Ctrl+PageUp: previous tab
        if mod == ctrl and event.keyval == Gdk.KEY_Page_Up:
            idx = self.notebook.get_current_page()
            if idx > 0:
                self.notebook.set_current_page(idx - 1)
            return True

        # Ctrl+PageDown: next tab
        if mod == ctrl and event.keyval == Gdk.KEY_Page_Down:
            idx = self.notebook.get_current_page()
            if idx < self.notebook.get_n_pages() - 1:
                self.notebook.set_current_page(idx + 1)
            return True

        return False

    def _on_delete_event(self, widget, event):
        return False


# ─── Main ─────────────────────────────────────────────────────────────────────

def main():
    GLib.set_prgname("bterminal")
    GLib.set_application_name("BTerminal")

    application = Gtk.Application(
        application_id="com.github.DexterFromLab.BTerminal",
        flags=Gio.ApplicationFlags.FLAGS_NONE,
    )

    def on_activate(app):
        windows = app.get_windows()
        if windows:
            windows[0].present()
            return
        win = BTerminalApp()
        app.add_window(win)

    application.connect("activate", on_activate)
    application.run(None)


if __name__ == "__main__":
    main()