@enruana/claude-orka 0.3.2 → 0.4.0

package/dist/electron/main/main.js

@@ -1,171 +1,1789 @@
-import { app, BrowserWindow, ipcMain } from 'electron';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { ClaudeOrka } from '../../src/core/ClaudeOrka';
-import chokidar from 'chokidar';
-import execa from 'execa';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Store windows by project path
-const windows = new Map();
-// Store active sessions
-let currentSessionId = null;
-let currentProjectPath = null;
-function createWindow(sessionId, projectPath) {
-    // If window already exists for this project, focus it
-    if (windows.has(projectPath)) {
-        const existingWindow = windows.get(projectPath);
-        existingWindow.focus();
-        return existingWindow;
-    }
-    const mainWindow = new BrowserWindow({
-        width: 600,
-        height: 800,
-        minWidth: 500,
-        minHeight: 600,
-        frame: false,
-        transparent: true,
-        alwaysOnTop: true,
-        resizable: true,
-        webPreferences: {
-            preload: path.join(__dirname, '../preload/preload.js'),
-            contextIsolation: true,
-            nodeIntegration: false,
-        },
-    });
-    // Store session info
-    currentSessionId = sessionId;
-    currentProjectPath = projectPath;
-    // Load UI
-    if (process.env.NODE_ENV === 'development') {
-        // Dev mode - load from Vite dev server
-        mainWindow.loadURL('http://localhost:5173');
-        mainWindow.webContents.openDevTools();
-    }
-    else {
-        // Production - load from built files
-        const indexPath = path.join(__dirname, '../renderer/index.html');
-        mainWindow.loadFile(indexPath);
-    }
-    // Watch state.json for changes
-    watchStateFile(projectPath, mainWindow);
-    // Store window
-    windows.set(projectPath, mainWindow);
-    mainWindow.on('closed', () => {
-        windows.delete(projectPath);
-    });
-    return mainWindow;
-}
-function watchStateFile(projectPath, window) {
-    const statePath = path.join(projectPath, '.claude-orka/state.json');
-    const watcher = chokidar.watch(statePath, {
-        persistent: true,
-        ignoreInitial: true,
-    });
-    watcher.on('change', async () => {
+// electron/main/main.ts
+import { app, BrowserWindow, ipcMain, shell } from "electron";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/core/StateManager.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+
+// src/utils/tmux.ts
+import execa from "execa";
+
+// src/utils/logger.ts
+import fs from "fs-extra";
+import path from "path";
+var Logger = class {
+  level = 1 /* INFO */;
+  logFilePath = null;
+  setLevel(level) {
+    this.level = level;
+  }
+  setLogFile(projectPath) {
+    const logDir = path.join(projectPath, ".claude-orka");
+    fs.ensureDirSync(logDir);
+    this.logFilePath = path.join(logDir, "orka.log");
+  }
+  writeToFile(level, ...args) {
+    if (!this.logFilePath) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const message = args.map(
+      (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+    ).join(" ");
+    const logLine = `${timestamp} [${level}] ${message}
+`;
+    try {
+      fs.appendFileSync(this.logFilePath, logLine);
+    } catch (error) {
+    }
+  }
+  debug(...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.log("[DEBUG]", ...args);
+      this.writeToFile("DEBUG", ...args);
+    }
+  }
+  info(...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log("[INFO]", ...args);
+      this.writeToFile("INFO", ...args);
+    }
+  }
+  warn(...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn("[WARN]", ...args);
+      this.writeToFile("WARN", ...args);
+    }
+  }
+  error(...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error("[ERROR]", ...args);
+      this.writeToFile("ERROR", ...args);
+    }
+  }
+};
+var logger = new Logger();
+
+// src/utils/tmux.ts
+var TmuxError = class extends Error {
+  constructor(message, command, originalError) {
+    super(message);
+    this.command = command;
+    this.originalError = originalError;
+    this.name = "TmuxError";
+  }
+};
+var TmuxCommands = class {
+  /**
+   * Verificar si tmux está disponible
+   */
+  static async isAvailable() {
+    try {
+      await execa("which", ["tmux"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Crear una nueva sesión tmux en modo detached
+   */
+  static async createSession(name, projectPath) {
+    try {
+      logger.debug(`Creating tmux session: ${name} at ${projectPath}`);
+      await execa("tmux", ["new-session", "-d", "-s", name, "-c", projectPath]);
+      logger.info(`Tmux session created: ${name}`);
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to create tmux session: ${name}`,
+        `tmux new-session -d -s ${name} -c ${projectPath}`,
+        error
+      );
+    }
+  }
+  /**
+   * Abrir una terminal que se adjunte a una sesión tmux existente
+   * (Solo macOS por ahora)
+   */
+  static async openTerminalWindow(sessionName) {
+    try {
+      logger.debug(`Opening terminal window for session: ${sessionName}`);
+      const platform = process.platform;
+      if (platform === "darwin") {
+        const script = `tell application "Terminal"
+          do script "tmux attach -t ${sessionName}"
+          activate
+        end tell`;
+        await execa("osascript", ["-e", script]);
+        logger.info("Terminal window opened (Terminal.app)");
+      } else if (platform === "linux") {
         try {
-            const orka = new ClaudeOrka(projectPath);
-            await orka.initialize();
-            if (currentSessionId) {
-                const session = await orka.getSession(currentSessionId);
-                if (session) {
-                    window.webContents.send('state-updated', session);
-                }
-            }
-        }
-        catch (error) {
-            console.error('Error watching state file:', error);
+          await execa("gnome-terminal", ["--", "tmux", "attach", "-t", sessionName]);
+          logger.info("Terminal window opened (gnome-terminal)");
+        } catch {
+          try {
+            await execa("xterm", ["-e", `tmux attach -t ${sessionName}`]);
+            logger.info("Terminal window opened (xterm)");
+          } catch {
+            logger.warn("Could not open terminal window on Linux");
+            throw new Error("No suitable terminal emulator found");
+          }
         }
+      } else {
+        logger.warn(`Platform ${platform} not supported for opening terminal windows`);
+        throw new Error(`Platform ${platform} not supported`);
+      }
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to open terminal window for session: ${sessionName}`,
+        `osascript/terminal`,
+        error
+      );
+    }
+  }
+  /**
+   * Cerrar una sesión tmux
+   */
+  static async killSession(sessionName) {
+    try {
+      logger.debug(`Killing tmux session: ${sessionName}`);
+      await execa("tmux", ["kill-session", "-t", sessionName]);
+      logger.info(`Tmux session killed: ${sessionName}`);
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to kill tmux session: ${sessionName}`,
+        `tmux kill-session -t ${sessionName}`,
+        error
+      );
+    }
+  }
+  /**
+   * Verificar si una sesión existe
+   */
+  static async sessionExists(sessionName) {
+    try {
+      await execa("tmux", ["has-session", "-t", sessionName]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Obtener el ID del pane principal de una sesión
+   */
+  static async getMainPaneId(sessionName) {
+    try {
+      logger.debug(`Getting main pane ID for session: ${sessionName}`);
+      const { stdout } = await execa("tmux", [
+        "list-panes",
+        "-t",
+        sessionName,
+        "-F",
+        "#{pane_id}"
+      ]);
+      const paneId = stdout.split("\n")[0];
+      logger.debug(`Main pane ID: ${paneId}`);
+      return paneId;
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to get main pane ID for session: ${sessionName}`,
+        `tmux list-panes -t ${sessionName} -F '#{pane_id}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Obtener el ID de la ventana principal de una sesión
+   */
+  static async getMainWindowId(sessionName) {
+    try {
+      logger.debug(`Getting main window ID for session: ${sessionName}`);
+      const { stdout } = await execa("tmux", [
+        "list-windows",
+        "-t",
+        sessionName,
+        "-F",
+        "#{window_id}"
+      ]);
+      const windowId = stdout.split("\n")[0];
+      logger.debug(`Main window ID: ${windowId}`);
+      return windowId;
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to get main window ID for session: ${sessionName}`,
+        `tmux list-windows -t ${sessionName} -F '#{window_id}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Dividir un pane (crear fork)
+   * @param sessionName Nombre de la sesión
+   * @param vertical Si es true, divide verticalmente (-h), si es false horizontalmente (-v)
+   * @returns ID del nuevo pane creado
+   */
+  static async splitPane(sessionName, vertical = false) {
+    try {
+      const direction = vertical ? "-h" : "-v";
+      logger.debug(`Splitting pane in session ${sessionName} (${vertical ? "vertical" : "horizontal"})`);
+      await execa("tmux", ["split-window", "-t", sessionName, direction]);
+      const { stdout } = await execa("tmux", [
+        "list-panes",
+        "-t",
+        sessionName,
+        "-F",
+        "#{pane_id}"
+      ]);
+      const panes = stdout.split("\n");
+      const newPaneId = panes[panes.length - 1];
+      logger.info(`New pane created: ${newPaneId}`);
+      return newPaneId;
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to split pane in session: ${sessionName}`,
+        `tmux split-window -t ${sessionName} ${vertical ? "-h" : "-v"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Listar todos los panes de una sesión
+   * @param sessionName Nombre de la sesión
+   * @returns Array de IDs de panes
+   */
+  static async listPanes(sessionName) {
+    try {
+      const { stdout } = await execa("tmux", [
+        "list-panes",
+        "-t",
+        sessionName,
+        "-F",
+        "#{pane_id}"
+      ]);
+      return stdout.trim().split("\n").filter(Boolean);
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to list panes for session: ${sessionName}`,
+        `tmux list-panes -t ${sessionName}`,
+        error
+      );
+    }
+  }
+  /**
+   * Cerrar un pane específico
+   */
+  static async killPane(paneId) {
+    try {
+      logger.debug(`Killing pane: ${paneId}`);
+      await execa("tmux", ["kill-pane", "-t", paneId]);
+      logger.info(`Pane killed: ${paneId}`);
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to kill pane: ${paneId}`,
+        `tmux kill-pane -t ${paneId}`,
+        error
+      );
+    }
+  }
+  /**
+   * Enviar texto a un pane (SIN Enter)
+   * IMPORTANTE: No envía Enter, debe llamarse a sendEnter() por separado
+   */
+  static async sendKeys(paneId, text) {
+    try {
+      logger.debug(`Sending keys to pane ${paneId}: ${text.substring(0, 50)}...`);
+      await execa("tmux", ["send-keys", "-t", paneId, text]);
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to send keys to pane: ${paneId}`,
+        `tmux send-keys -t ${paneId} "${text}"`,
+        error
+      );
+    }
+  }
+  /**
+   * Enviar SOLO Enter a un pane
+   */
+  static async sendEnter(paneId) {
+    try {
+      logger.debug(`Sending Enter to pane: ${paneId}`);
+      await execa("tmux", ["send-keys", "-t", paneId, "Enter"]);
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to send Enter to pane: ${paneId}`,
+        `tmux send-keys -t ${paneId} Enter`,
+        error
+      );
+    }
+  }
+  /**
+   * Enviar teclas especiales (flechas, escape, etc.)
+   * @param paneId ID del pane
+   * @param key Nombre de la tecla: 'Up', 'Down', 'Left', 'Right', 'Escape', 'Space', etc.
+   */
+  static async sendSpecialKey(paneId, key) {
+    try {
+      logger.debug(`Sending special key '${key}' to pane: ${paneId}`);
+      await execa("tmux", ["send-keys", "-t", paneId, key]);
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to send special key '${key}' to pane: ${paneId}`,
+        `tmux send-keys -t ${paneId} ${key}`,
+        error
+      );
+    }
+  }
+  /**
+   * Capturar el contenido de un pane
+   * @param paneId ID del pane
+   * @param startLine Línea desde donde empezar a capturar (negativo = desde el final)
+   * @returns Contenido del pane
+   */
+  static async capturePane(paneId, startLine = -100) {
+    try {
+      logger.debug(`Capturing pane ${paneId} from line ${startLine}`);
+      const { stdout } = await execa("tmux", [
+        "capture-pane",
+        "-t",
+        paneId,
+        "-p",
+        "-S",
+        startLine.toString()
+      ]);
+      return stdout;
+    } catch (error) {
+      throw new TmuxError(
+        `Failed to capture pane: ${paneId}`,
+        `tmux capture-pane -t ${paneId} -p -S ${startLine}`,
+        error
+      );
+    }
+  }
+  /**
+   * Listar todas las sesiones tmux
+   */
+  static async listSessions() {
+    try {
+      const { stdout } = await execa("tmux", ["list-sessions", "-F", "#{session_id}:#{session_name}"]);
+      return stdout.split("\n").map((line) => {
+        const [id, name] = line.split(":");
+        return { id, name };
+      });
+    } catch (error) {
+      if (error.stderr?.includes("no server running")) {
+        return [];
+      }
+      throw new TmuxError(
+        "Failed to list tmux sessions",
+        "tmux list-sessions",
+        error
+      );
+    }
+  }
+};
+
+// src/utils/claude-history.ts
+import fs2 from "fs-extra";
+import os from "os";
+import path2 from "path";
+var CLAUDE_HISTORY_PATH = path2.join(os.homedir(), ".claude", "history.jsonl");
+async function readClaudeHistory() {
+  try {
+    const exists = await fs2.pathExists(CLAUDE_HISTORY_PATH);
+    if (!exists) {
+      logger.warn(`Claude history file not found: ${CLAUDE_HISTORY_PATH}`);
+      return [];
+    }
+    const content = await fs2.readFile(CLAUDE_HISTORY_PATH, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        entries.push(entry);
+      } catch (err) {
+        logger.warn(`Failed to parse history line: ${line}`);
+      }
+    }
+    return entries;
+  } catch (error) {
+    logger.error(`Error reading Claude history: ${error}`);
+    return [];
+  }
+}
+async function getExistingSessionIds() {
+  const entries = await readClaudeHistory();
+  return new Set(entries.map((e) => e.sessionId));
+}
+async function detectNewSessionId(previousIds, maxWaitMs = 1e4, pollIntervalMs = 500) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < maxWaitMs) {
+    const currentIds = await getExistingSessionIds();
+    for (const id of currentIds) {
+      if (!previousIds.has(id)) {
+        logger.info(`Detected new Claude session: ${id}`);
+        return id;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  logger.warn("Timeout waiting for new Claude session ID");
+  return null;
+}
+
+// src/core/StateManager.ts
+var StateManager = class {
+  projectPath;
+  orkaDir;
+  statePath;
+  constructor(projectPath) {
+    this.projectPath = path3.resolve(projectPath);
+    this.orkaDir = path3.join(this.projectPath, ".claude-orka");
+    this.statePath = path3.join(this.orkaDir, "state.json");
+  }
+  /**
+   * Initialize StateManager
+   * Creates necessary folders if they don't exist
+   */
+  async initialize() {
+    logger.debug("Initializing StateManager");
+    await this.ensureDirectories();
+    if (!await fs3.pathExists(this.statePath)) {
+      logger.info("Creating initial state.json");
+      const initialState = {
+        version: "1.0.0",
+        projectPath: this.projectPath,
+        sessions: [],
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.save(initialState);
+    }
+    logger.info("StateManager initialized");
+  }
+  /**
+   * Create directory structure
+   */
+  async ensureDirectories() {
+    await fs3.ensureDir(this.orkaDir);
+    logger.debug("Directories ensured");
+  }
+  /**
+   * Read current state
+   */
+  async read() {
+    try {
+      const content = await fs3.readFile(this.statePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      logger.error("Failed to read state:", error);
+      throw new Error(`Failed to read state: ${error.message}`);
+    }
+  }
+  /**
+   * Save state
+   */
+  async save(state) {
+    try {
+      state.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      await fs3.writeFile(this.statePath, JSON.stringify(state, null, 2), "utf-8");
+      logger.debug("State saved");
+    } catch (error) {
+      logger.error("Failed to save state:", error);
+      throw new Error(`Failed to save state: ${error.message}`);
+    }
+  }
+  // --- OPERACIONES DE SESIONES ---
+  /**
+   * Obtener el estado completo
+   */
+  async getState() {
+    return await this.read();
+  }
+  /**
+   * Listar todas las sesiones con filtros opcionales
+   */
+  async listSessions(filters) {
+    const state = await this.read();
+    let sessions = state.sessions;
+    if (filters?.status) {
+      sessions = sessions.filter((s) => s.status === filters.status);
+    }
+    if (filters?.name) {
+      sessions = sessions.filter(
+        (s) => s.name.toLowerCase().includes(filters.name.toLowerCase())
+      );
+    }
+    return sessions;
+  }
+  /**
+   * Agregar una nueva sesión
+   */
+  async addSession(session) {
+    const state = await this.read();
+    state.sessions.push(session);
+    await this.save(state);
+    logger.info(`Session added: ${session.id}`);
+  }
+  /**
+   * Obtener una sesión por ID
+   */
+  async getSession(sessionId) {
+    const state = await this.read();
+    return state.sessions.find((s) => s.id === sessionId) || null;
+  }
+  /**
+   * Obtener todas las sesiones con filtros opcionales
+   */
+  async getAllSessions(filters) {
+    const state = await this.read();
+    let sessions = state.sessions;
+    if (filters?.status) {
+      sessions = sessions.filter((s) => s.status === filters.status);
+    }
+    if (filters?.name) {
+      sessions = sessions.filter((s) => s.name.includes(filters.name));
+    }
+    return sessions;
+  }
+  /**
+   * Actualizar el estado de una sesión
+   */
+  async updateSessionStatus(sessionId, status) {
+    const state = await this.read();
+    const session = state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    session.status = status;
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(state);
+    logger.info(`Session ${sessionId} status updated to: ${status}`);
+  }
+  /**
+   * Actualizar una sesión completa
+   */
+  async updateSession(sessionId, updates) {
+    const state = await this.read();
+    const sessionIndex = state.sessions.findIndex((s) => s.id === sessionId);
+    if (sessionIndex === -1) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    state.sessions[sessionIndex] = {
+      ...state.sessions[sessionIndex],
+      ...updates,
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.save(state);
+    logger.debug(`Session ${sessionId} updated`);
+  }
+  /**
+   * Reemplazar una sesión completa
+   */
+  async replaceSession(session) {
+    const state = await this.read();
+    const sessionIndex = state.sessions.findIndex((s) => s.id === session.id);
+    if (sessionIndex === -1) {
+      throw new Error(`Session not found: ${session.id}`);
+    }
+    state.sessions[sessionIndex] = session;
+    await this.save(state);
+    logger.debug(`Session ${session.id} replaced`);
+  }
+  /**
+   * Eliminar una sesión permanentemente
+   */
+  async deleteSession(sessionId) {
+    const state = await this.read();
+    state.sessions = state.sessions.filter((s) => s.id !== sessionId);
+    await this.save(state);
+    logger.info(`Session deleted: ${sessionId}`);
+  }
+  // --- OPERACIONES DE FORKS ---
+  /**
+   * Agregar un fork a una sesión
+   */
+  async addFork(sessionId, fork) {
+    const state = await this.read();
+    const session = state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    session.forks.push(fork);
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(state);
+    logger.info(`Fork added to session ${sessionId}: ${fork.id}`);
+  }
+  /**
+   * Obtener un fork específico
+   */
+  async getFork(sessionId, forkId) {
+    const session = await this.getSession(sessionId);
+    if (!session) return null;
+    return session.forks.find((f) => f.id === forkId) || null;
+  }
+  /**
+   * Actualizar el estado de un fork
+   */
+  async updateForkStatus(sessionId, forkId, status) {
+    const state = await this.read();
+    const session = state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const fork = session.forks.find((f) => f.id === forkId);
+    if (!fork) {
+      throw new Error(`Fork not found: ${forkId}`);
+    }
+    fork.status = status;
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(state);
+    logger.info(`Fork ${forkId} status updated to: ${status}`);
+  }
+  /**
+   * Actualizar el path del contexto de un fork
+   */
+  async updateForkContext(sessionId, forkId, contextPath) {
+    const state = await this.read();
+    const session = state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const fork = session.forks.find((f) => f.id === forkId);
+    if (!fork) {
+      throw new Error(`Fork not found: ${forkId}`);
+    }
+    fork.contextPath = contextPath;
+    await this.save(state);
+    logger.debug(`Fork ${forkId} context updated: ${contextPath}`);
+  }
+  /**
+   * Actualizar un fork completo
+   */
+  async updateFork(sessionId, forkId, updates) {
+    const state = await this.read();
+    const session = state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const forkIndex = session.forks.findIndex((f) => f.id === forkId);
+    if (forkIndex === -1) {
+      throw new Error(`Fork not found: ${forkId}`);
+    }
+    session.forks[forkIndex] = {
+      ...session.forks[forkIndex],
+      ...updates
+    };
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(state);
+    logger.debug(`Fork ${forkId} updated`);
+  }
+  /**
+   * Eliminar un fork
+   */
+  async deleteFork(sessionId, forkId) {
+    const state = await this.read();
+    const session = state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const forkIndex = session.forks.findIndex((f) => f.id === forkId);
+    if (forkIndex === -1) {
+      throw new Error(`Fork not found: ${forkId}`);
+    }
+    session.forks.splice(forkIndex, 1);
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(state);
+    logger.debug(`Fork ${forkId} deleted`);
+  }
+  // --- OPERACIONES DE CONTEXTOS ---
+  /**
+   * Guardar un contexto en archivo
+   */
+  async saveContext(type, id, content) {
+    const contextPath = type === "session" ? this.getSessionContextPath(id) : this.getForkContextPath(id);
+    const fullPath = path3.join(this.projectPath, contextPath);
+    await fs3.writeFile(fullPath, content, "utf-8");
+    logger.info(`Context saved: ${contextPath}`);
+    return contextPath;
+  }
+  /**
+   * Leer un contexto desde archivo
+   */
+  async readContext(contextPath) {
+    const fullPath = path3.join(this.projectPath, contextPath);
+    if (!await fs3.pathExists(fullPath)) {
+      throw new Error(`Context file not found: ${contextPath}`);
+    }
+    return await fs3.readFile(fullPath, "utf-8");
+  }
+  // --- HELPERS ---
+  /**
+   * Obtener el path para el contexto de una sesión
+   */
+  getSessionContextPath(sessionId) {
+    return `.claude-orka/sessions/${sessionId}.md`;
+  }
+  /**
+   * Obtener el path para el contexto de un fork
+   */
+  getForkContextPath(forkId) {
+    return `.claude-orka/forks/${forkId}.md`;
+  }
+  /**
+   * Obtener el path para un export manual
+   */
+  getExportPath(forkId, name) {
+    return `.claude-orka/exports/${forkId}-${name}.md`;
+  }
+};
+
+// src/core/SessionManager.ts
+import { v4 as uuidv4 } from "uuid";
+import path4 from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import fs4 from "fs-extra";
+import { spawn } from "child_process";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var SessionManager = class {
+  stateManager;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.stateManager = new StateManager(projectPath);
+  }
+  /**
+   * Initialize el manager
+   */
+  async initialize() {
+    await this.stateManager.initialize();
+  }
+  /**
+   * Obtener el state
+   */
+  async getState() {
+    return await this.stateManager.getState();
+  }
+  // ==========================================
+  // SESIONES
+  // ==========================================
+  /**
+   * Crear una nueva sesión de Claude Code
+   */
+  async createSession(name, openTerminal = true) {
+    const sessionId = uuidv4();
+    const sessionName = name || `Session-${Date.now()}`;
+    const tmuxSessionId = `orka-${sessionId}`;
+    logger.info(`Creating session: ${sessionName}`);
+    await TmuxCommands.createSession(tmuxSessionId, this.projectPath);
+    if (openTerminal) {
+      await TmuxCommands.openTerminalWindow(tmuxSessionId);
+    }
+    await sleep(2e3);
+    const paneId = await TmuxCommands.getMainPaneId(tmuxSessionId);
+    logger.debug(`Main pane ID: ${paneId}`);
+    const claudeSessionId = uuidv4();
+    await this.initializeClaude(paneId, {
+      type: "new",
+      sessionId: claudeSessionId,
+      sessionName
     });
-    window.on('closed', () => {
-        watcher.close();
+    const session = {
+      id: sessionId,
+      name: sessionName,
+      tmuxSessionId,
+      status: "active",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      main: {
+        claudeSessionId,
+        tmuxPaneId: paneId,
+        status: "active"
+      },
+      forks: []
+    };
+    await this.stateManager.addSession(session);
+    logger.info(`Session created: ${sessionName} (${sessionId})`);
+    if (openTerminal) {
+      await this.launchUI(sessionId);
+    }
+    return session;
+  }
+  /**
+   * Restaurar una sesión guardada
+   */
+  async resumeSession(sessionId, openTerminal = true) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    logger.info(`Resuming session: ${session.name}`);
+    const tmuxSessionId = `orka-${sessionId}`;
+    if (session.status === "active") {
+      logger.info(`Session is already active, reconnecting...`);
+      if (openTerminal) {
+        await TmuxCommands.openTerminalWindow(tmuxSessionId);
+        await this.launchUI(sessionId);
+      }
+      return session;
+    }
+    await TmuxCommands.createSession(tmuxSessionId, this.projectPath);
+    if (openTerminal) {
+      await TmuxCommands.openTerminalWindow(tmuxSessionId);
+    }
+    await sleep(2e3);
+    const paneId = await TmuxCommands.getMainPaneId(tmuxSessionId);
+    await this.initializeClaude(paneId, {
+      type: "resume",
+      resumeSessionId: session.main.claudeSessionId,
+      sessionName: session.name
     });
-}
-// IPC Handlers
-ipcMain.handle('get-session', async () => {
-    if (!currentSessionId || !currentProjectPath) {
-        throw new Error('No active session');
-    }
-    const orka = new ClaudeOrka(currentProjectPath);
-    await orka.initialize();
-    const session = await orka.getSession(currentSessionId);
+    session.tmuxSessionId = tmuxSessionId;
+    session.main.tmuxPaneId = paneId;
+    session.main.status = "active";
+    session.status = "active";
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+    const forksToRestore = session.forks.filter((f) => f.status !== "merged");
+    if (forksToRestore.length > 0) {
+      logger.info(`Restoring ${forksToRestore.length} fork(s)...`);
+      for (const fork of forksToRestore) {
+        await this.resumeFork(sessionId, fork.id);
+      }
+    }
+    logger.info(`Session resumed: ${session.name}`);
+    if (openTerminal) {
+      await this.launchUI(sessionId);
+    }
     return session;
-});
-ipcMain.handle('select-node', async (_, nodeId) => {
-    if (!currentSessionId || !currentProjectPath) {
-        throw new Error('No active session');
-    }
-    const orka = new ClaudeOrka(currentProjectPath);
-    await orka.initialize();
-    const session = await orka.getSession(currentSessionId);
-    if (!session)
-        return;
-    // Get tmux pane ID for the selected node
-    let tmuxPaneId;
-    if (nodeId === 'main') {
-        tmuxPaneId = session.main?.tmuxPaneId;
+  }
+  /**
+   * Close a session (save and kill tmux)
+   */
+  async closeSession(sessionId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
     }
-    else {
-        const fork = session.forks.find((f) => f.id === nodeId);
-        tmuxPaneId = fork?.tmuxPaneId;
+    logger.info(`Closing session: ${session.name}`);
+    const activeForks = session.forks.filter((f) => f.status === "active");
+    for (const fork of activeForks) {
+      await this.closeFork(sessionId, fork.id);
     }
-    if (tmuxPaneId) {
-        // Focus the tmux pane
-        await execa('tmux', ['select-pane', '-t', tmuxPaneId]);
+    if (session.tmuxSessionId) {
+      await TmuxCommands.killSession(session.tmuxSessionId);
     }
-});
-ipcMain.handle('create-fork', async (_, sessionId, name) => {
-    if (!currentProjectPath) {
-        throw new Error('No active project');
+    session.main.status = "saved";
+    session.main.tmuxPaneId = void 0;
+    session.status = "saved";
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+    logger.info(`Session closed: ${session.name}`);
+  }
+  /**
+   * Eliminar una sesión permanentemente
+   */
+  async deleteSession(sessionId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    logger.info(`Deleting session: ${session.name}`);
+    if (session.status === "active") {
+      await this.closeSession(sessionId);
+    }
+    await this.stateManager.deleteSession(sessionId);
+    logger.info(`Session deleted: ${session.name}`);
+  }
+  /**
+   * Listar sesiones con filtros opcionales
+   */
+  async listSessions(filters) {
+    return await this.stateManager.listSessions(filters);
+  }
+  /**
+   * Obtener una sesión por ID
+   */
+  async getSession(sessionId) {
+    return await this.stateManager.getSession(sessionId);
+  }
+  // ==========================================
+  // FORKS
+  // ==========================================
+  /**
+   * Crear un fork (rama de conversación)
+   */
+  async createFork(sessionId, name, parentId = "main", vertical = false) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const forkId = uuidv4();
+    const forkName = name || `Fork-${session.forks.length + 1}`;
+    logger.info(`Creating fork: ${forkName} from parent ${parentId} in session ${session.name}`);
+    let parentClaudeSessionId;
+    if (parentId === "main") {
+      parentClaudeSessionId = session.main.claudeSessionId;
+    } else {
+      const parentFork = session.forks.find((f) => f.id === parentId);
+      if (!parentFork) {
+        throw new Error(`Parent fork ${parentId} not found`);
+      }
+      parentClaudeSessionId = parentFork.claudeSessionId;
+    }
+    logger.debug(`Parent Claude session ID: ${parentClaudeSessionId}`);
+    await TmuxCommands.splitPane(session.tmuxSessionId, vertical);
+    await sleep(1e3);
+    const allPanes = await TmuxCommands.listPanes(session.tmuxSessionId);
+    const forkPaneId = allPanes[allPanes.length - 1];
+    logger.debug(`Fork pane ID: ${forkPaneId}`);
+    const existingIds = await getExistingSessionIds();
+    logger.debug(`Existing sessions before fork: ${existingIds.size}`);
+    await this.initializeClaude(forkPaneId, {
+      type: "fork",
+      parentSessionId: parentClaudeSessionId,
+      forkName
+    });
+    logger.info("Detecting fork session ID from history...");
+    const detectedForkId = await detectNewSessionId(existingIds, 3e4, 500);
+    if (!detectedForkId) {
+      throw new Error(
+        "Failed to detect fork session ID. Fork may not have been created. Check if the parent session is valid."
+      );
+    }
+    logger.info(`Fork session ID detected: ${detectedForkId}`);
+    const fork = {
+      id: forkId,
+      name: forkName,
+      parentId,
+      claudeSessionId: detectedForkId,
+      // ✅ ID real detectado
+      tmuxPaneId: forkPaneId,
+      status: "active",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    session.forks.push(fork);
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+    logger.info(`Fork created: ${forkName} (${forkId})`);
+    return fork;
+  }
+  /**
+   * Restaurar un fork guardado
+   */
+  async resumeFork(sessionId, forkId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const fork = session.forks.find((f) => f.id === forkId);
+    if (!fork) {
+      throw new Error(`Fork ${forkId} not found`);
     }
-    const orka = new ClaudeOrka(currentProjectPath);
-    await orka.initialize();
-    const fork = await orka.createFork(sessionId, name);
+    logger.info(`Resuming fork: ${fork.name}`);
+    await TmuxCommands.splitPane(session.tmuxSessionId, false);
+    await sleep(1e3);
+    const allPanes = await TmuxCommands.listPanes(session.tmuxSessionId);
+    const forkPaneId = allPanes[allPanes.length - 1];
+    await this.initializeClaude(forkPaneId, {
+      type: "resume",
+      resumeSessionId: fork.claudeSessionId,
+      sessionName: fork.name
+    });
+    fork.tmuxPaneId = forkPaneId;
+    fork.status = "active";
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+    logger.info(`Fork resumed: ${fork.name}`);
     return fork;
+  }
+  /**
+   * Cerrar un fork
+   */
+  async closeFork(sessionId, forkId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const fork = session.forks.find((f) => f.id === forkId);
+    if (!fork) {
+      throw new Error(`Fork ${forkId} not found`);
+    }
+    logger.info(`Closing fork: ${fork.name}`);
+    if (fork.tmuxPaneId) {
+      await TmuxCommands.killPane(fork.tmuxPaneId);
+    }
+    fork.status = "closed";
+    fork.tmuxPaneId = void 0;
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+    logger.info(`Fork closed: ${fork.name}`);
+  }
+  /**
+   * Eliminar un fork permanentemente
+   */
+  async deleteFork(sessionId, forkId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const forkIndex = session.forks.findIndex((f) => f.id === forkId);
+    if (forkIndex === -1) {
+      throw new Error(`Fork ${forkId} not found`);
+    }
+    const fork = session.forks[forkIndex];
+    logger.info(`Deleting fork: ${fork.name}`);
+    if (fork.status === "active") {
+      await this.closeFork(sessionId, forkId);
+    }
+    session.forks.splice(forkIndex, 1);
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+    logger.info(`Fork deleted: ${fork.name}`);
+  }
+  // ==========================================
+  // COMANDOS
+  // ==========================================
+  /**
+   * Enviar comando a main
+   */
+  async sendToMain(sessionId, command) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    if (!session.main.tmuxPaneId) {
+      throw new Error("Main pane is not active");
+    }
+    logger.info(`Sending command to main: ${command}`);
+    await TmuxCommands.sendKeys(session.main.tmuxPaneId, command);
+    await TmuxCommands.sendEnter(session.main.tmuxPaneId);
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+  }
+  /**
+   * Enviar comando a un fork
+   */
+  async sendToFork(sessionId, forkId, command) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const fork = session.forks.find((f) => f.id === forkId);
+    if (!fork) {
+      throw new Error(`Fork ${forkId} not found`);
+    }
+    if (!fork.tmuxPaneId) {
+      throw new Error("Fork pane is not active");
+    }
+    logger.info(`Sending command to fork ${fork.name}: ${command}`);
+    await TmuxCommands.sendKeys(fork.tmuxPaneId, command);
+    await TmuxCommands.sendEnter(fork.tmuxPaneId);
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+  }
+  // ==========================================
+  // EXPORT & MERGE
+  // ==========================================
+  /**
+   * Generar export de un fork con resumen
+   * Envía un prompt a Claude pidiendo que genere resumen y exporte
+   */
+  async generateForkExport(sessionId, forkId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const fork = session.forks.find((f) => f.id === forkId);
+    if (!fork) {
+      throw new Error(`Fork ${forkId} not found`);
+    }
+    logger.info(`Generating export for fork: ${fork.name}`);
+    const exportsDir = path4.join(this.projectPath, ".claude-orka", "exports");
+    await fs4.ensureDir(exportsDir);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const exportName = `fork-${fork.name}-${timestamp}.md`;
+    const relativeExportPath = `.claude-orka/exports/${exportName}`;
+    const absoluteExportPath = path4.join(this.projectPath, relativeExportPath);
+    const prompt = `
+Please generate a complete summary of this fork conversation "${fork.name}" and save it to the file:
+\`${absoluteExportPath}\`
+
+The summary should include:
+
+## Executive Summary
+- What was attempted to achieve in this fork
+- Why this exploration branch was created
+
+## Changes Made
+- Detailed list of changes, modified files, written code
+- Technical decisions made
+
+## Results
+- What works correctly
+- What problems were encountered
+- What remains pending
+
+## Recommendations
+- Suggested next steps
+- How to integrate this to main
+- Important considerations
+
+Write the summary in Markdown format and save it to the specified file.
+`.trim();
+    if (!fork.tmuxPaneId) {
+      throw new Error("Fork pane is not active. Cannot send export command.");
+    }
+    await TmuxCommands.sendKeys(fork.tmuxPaneId, prompt);
+    await TmuxCommands.sendEnter(fork.tmuxPaneId);
+    fork.contextPath = relativeExportPath;
+    await this.stateManager.replaceSession(session);
+    logger.info(`Export generation requested`);
+    logger.info(`  Filename: ${exportName}`);
+    logger.info(`  Relative path (saved in state): ${relativeExportPath}`);
+    logger.info(`  Absolute path (sent to Claude): ${absoluteExportPath}`);
+    logger.warn("IMPORTANT: Wait for Claude to complete before calling merge()");
+    return relativeExportPath;
+  }
+  /**
+   * Hacer merge de un fork a main
+   * PREREQUISITO: Debes llamar a generateForkExport() primero y esperar
+   */
+  async mergeFork(sessionId, forkId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const fork = session.forks.find((f) => f.id === forkId);
+    if (!fork) {
+      throw new Error(`Fork ${forkId} not found`);
+    }
+    if (!fork.contextPath) {
+      throw new Error(
+        "Fork does not have an exported context. Call generateForkExport() first."
+      );
+    }
+    const parentId = fork.parentId;
+    const parentName = parentId === "main" ? "MAIN" : session.forks.find((f) => f.id === parentId)?.name || parentId;
+    logger.info(`Merging fork ${fork.name} to parent ${parentName}`);
+    let parentTmuxPaneId;
+    if (parentId === "main") {
+      parentTmuxPaneId = session.main.tmuxPaneId;
+    } else {
+      const parentFork = session.forks.find((f) => f.id === parentId);
+      if (!parentFork) {
+        throw new Error(`Parent fork ${parentId} not found`);
+      }
+      parentTmuxPaneId = parentFork.tmuxPaneId;
+    }
+    if (!parentTmuxPaneId) {
+      throw new Error(`Parent ${parentName} is not active. Cannot send merge command.`);
+    }
+    let contextPath = fork.contextPath;
+    let fullPath = path4.join(this.projectPath, contextPath);
+    let exists = await fs4.pathExists(fullPath);
+    if (!exists) {
+      logger.warn(`Export file not found: ${contextPath}. Looking for most recent export...`);
+      const exportsDir = path4.join(this.projectPath, ".claude-orka", "exports");
+      const files = await fs4.readdir(exportsDir);
+      const forkExports = files.filter((f) => f.startsWith(`fork-${fork.name}-`) && f.endsWith(".md")).sort().reverse();
+      if (forkExports.length > 0) {
+        contextPath = `.claude-orka/exports/${forkExports[0]}`;
+        fullPath = path4.join(this.projectPath, contextPath);
+        exists = await fs4.pathExists(fullPath);
+        logger.info(`Using most recent export: ${contextPath}`);
+      }
+    }
+    if (!exists) {
+      throw new Error(
+        `No export file found for fork "${fork.name}". Please run Export first and wait for Claude to complete.`
+      );
+    }
+    const mergePrompt = `
+I have completed work on the fork "${fork.name}".
+Please read the file \`${contextPath}\` which contains:
+1. An executive summary of the work completed
+2. The complete context of the fork conversation
+
+Analyze the content and help me integrate the changes and learnings from the fork into this conversation.
+`.trim();
+    await TmuxCommands.sendKeys(parentTmuxPaneId, mergePrompt);
+    await TmuxCommands.sendEnter(parentTmuxPaneId);
+    fork.status = "merged";
+    fork.mergedToMain = true;
+    fork.mergedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (fork.tmuxPaneId) {
+      await TmuxCommands.killPane(fork.tmuxPaneId);
+      fork.tmuxPaneId = void 0;
+    }
+    session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateManager.replaceSession(session);
+    logger.info(`Fork ${fork.name} merged to main`);
+  }
+  /**
+   * Export manual de un fork (deprecated - usa generateForkExport)
+   */
+  async exportFork(sessionId, forkId) {
+    logger.warn("exportFork() is deprecated. Use generateForkExport() instead.");
+    return await this.generateForkExport(sessionId, forkId);
+  }
+  // ==========================================
+  // HELPERS PRIVADOS
+  // ==========================================
+  /**
+   * Initialize Claude en un pane con prompt inicial
+   */
+  async initializeClaude(paneId, options) {
+    const { type, sessionId, resumeSessionId, parentSessionId, sessionName, forkName } = options;
+    await TmuxCommands.sendKeys(paneId, `cd ${this.projectPath}`);
+    await TmuxCommands.sendEnter(paneId);
+    await sleep(500);
+    let command = "";
+    switch (type) {
+      case "new":
+        const newPrompt = `Hello, this is a new main session called "${sessionName}". We are working on the project.`;
+        command = `claude --session-id ${sessionId} "${newPrompt}"`;
+        break;
+      case "resume":
+        const resumePrompt = `Resuming session "${sessionName}".`;
+        command = `claude --resume ${resumeSessionId} "${resumePrompt}"`;
+        break;
+      case "fork":
+        const forkPrompt = `This is a fork called "${forkName}". Keep in mind we are exploring an alternative to the main conversation.`;
+        command = `claude --resume ${parentSessionId} --fork-session "${forkPrompt}"`;
+        break;
+    }
+    logger.info(`Executing: ${command}`);
+    await TmuxCommands.sendKeys(paneId, command);
+    await TmuxCommands.sendEnter(paneId);
+    await sleep(8e3);
+  }
+  /**
+   * Launch Electron UI for a session
+   */
+  async launchUI(sessionId) {
+    try {
+      let electronPath;
+      try {
+        electronPath = require2("electron");
+      } catch (error) {
+        logger.warn("Electron not available, skipping UI launch");
+        return;
+      }
+      let mainPath = path4.join(__dirname, "../../electron/main/main.js");
+      if (!fs4.existsSync(mainPath)) {
+        mainPath = path4.join(__dirname, "../../dist/electron/main/main.js");
+      }
+      if (!fs4.existsSync(mainPath)) {
+        logger.warn(`Electron main.js not found at ${mainPath}, skipping UI launch`);
+        return;
+      }
+      const electronProcess = spawn(
+        electronPath,
+        [mainPath, "--session-id", sessionId, "--project-path", this.projectPath],
+        {
+          detached: true,
+          stdio: "ignore"
+        }
+      );
+      electronProcess.unref();
+      logger.info(`Launched UI for session ${sessionId}`);
+    } catch (error) {
+      logger.warn(`Failed to launch UI: ${error}`);
+    }
+  }
+};
+
+// src/core/ClaudeOrka.ts
+var ClaudeOrka = class {
+  sessionManager;
+  /**
+   * Create a ClaudeOrka instance
+   * @param projectPath Absolute path to the project
+   */
+  constructor(projectPath) {
+    logger.setLogFile(projectPath);
+    this.sessionManager = new SessionManager(projectPath);
+  }
+  /**
+   * Initialize ClaudeOrka
+   * Creates the .claude-orka/ structure if it doesn't exist
+   */
+  async initialize() {
+    logger.info("Initializing ClaudeOrka");
+    await this.sessionManager.initialize();
+  }
+  // --- SESSIONS ---
+  /**
+   * Create a new Claude Code session
+   * @param name Optional name for the session
+   * @param openTerminal Whether to open a terminal window (default: true)
+   * @returns Created session
+   */
+  async createSession(name, openTerminal) {
+    return await this.sessionManager.createSession(name, openTerminal);
+  }
+  /**
+   * Resume a saved session
+   * @param sessionId Session ID to resume
+   * @param openTerminal Whether to open a terminal window (default: true)
+   * @returns Resumed session
+   */
+  async resumeSession(sessionId, openTerminal) {
+    return await this.sessionManager.resumeSession(sessionId, openTerminal);
+  }
+  /**
+   * Close a session
+   * @param sessionId Session ID
+   */
+  async closeSession(sessionId) {
+    await this.sessionManager.closeSession(sessionId);
+  }
+  /**
+   * Permanently delete a session
+   * @param sessionId Session ID
+   */
+  async deleteSession(sessionId) {
+    await this.sessionManager.deleteSession(sessionId);
+  }
+  /**
+   * List sessions with optional filters
+   * @param filters Optional filters (status, name)
+   * @returns Array of sessions
+   */
+  async listSessions(filters) {
+    return await this.sessionManager.listSessions(filters);
+  }
+  /**
+   * Get a session by ID
+   * @param sessionId Session ID
+   * @returns Session or null if not found
+   */
+  async getSession(sessionId) {
+    return await this.sessionManager.getSession(sessionId);
+  }
+  /**
+   * Get complete project summary
+   * Includes statistics of all sessions and their forks
+   * @returns Project summary with all sessions and statistics
+   */
+  async getProjectSummary() {
+    const sessions = await this.sessionManager.listSessions();
+    const state = await this.sessionManager.getState();
+    const sessionSummaries = sessions.map((session) => {
+      const forkSummaries = session.forks.map((fork) => ({
+        id: fork.id,
+        name: fork.name,
+        claudeSessionId: fork.claudeSessionId,
+        status: fork.status,
+        createdAt: fork.createdAt,
+        hasContext: !!fork.contextPath,
+        contextPath: fork.contextPath,
+        mergedToMain: fork.mergedToMain || false,
+        mergedAt: fork.mergedAt
+      }));
+      const activeForks = session.forks.filter((f) => f.status === "active").length;
+      const savedForks = session.forks.filter((f) => f.status === "saved").length;
+      const mergedForks = session.forks.filter((f) => f.status === "merged").length;
+      return {
+        id: session.id,
+        name: session.name,
+        claudeSessionId: session.main.claudeSessionId,
+        status: session.status,
+        createdAt: session.createdAt,
+        lastActivity: session.lastActivity,
+        totalForks: session.forks.length,
+        activeForks,
+        savedForks,
+        mergedForks,
+        forks: forkSummaries
+      };
+    });
+    const activeSessions = sessions.filter((s) => s.status === "active").length;
+    const savedSessions = sessions.filter((s) => s.status === "saved").length;
+    return {
+      projectPath: state.projectPath,
+      totalSessions: sessions.length,
+      activeSessions,
+      savedSessions,
+      sessions: sessionSummaries,
+      lastUpdated: state.lastUpdated
+    };
+  }
+  // --- FORKS ---
+  /**
+   * Create a fork (conversation branch)
+   * @param sessionId Session ID
+   * @param name Optional fork name
+   * @param parentId Parent fork/session ID (default: 'main')
+   * @param vertical Whether to split vertically (default: false = horizontal)
+   * @returns Created fork
+   */
+  async createFork(sessionId, name, parentId = "main", vertical) {
+    return await this.sessionManager.createFork(sessionId, name, parentId, vertical);
+  }
+  /**
+   * Close a fork
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   */
+  async closeFork(sessionId, forkId) {
+    await this.sessionManager.closeFork(sessionId, forkId);
+  }
+  /**
+   * Resume a saved fork
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   * @returns Resumed fork
+   */
+  async resumeFork(sessionId, forkId) {
+    return await this.sessionManager.resumeFork(sessionId, forkId);
+  }
+  /**
+   * Permanently delete a fork
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   */
+  async deleteFork(sessionId, forkId) {
+    await this.sessionManager.deleteFork(sessionId, forkId);
+  }
+  // --- COMANDOS ---
+  /**
+   * Send command to a session or fork
+   * @param sessionId Session ID
+   * @param command Command to send
+   * @param target Fork ID (optional, if not specified goes to main)
+   */
+  async send(sessionId, command, target) {
+    if (target) {
+      await this.sessionManager.sendToFork(sessionId, target, command);
+    } else {
+      await this.sessionManager.sendToMain(sessionId, command);
+    }
+  }
+  // --- EXPORT & MERGE ---
+  /**
+   * Export fork context (old method - uses manual capture)
+   * @deprecated Use generateForkExport() instead for Claude to generate the summary
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   * @returns Path to the exported file
+   */
+  async export(sessionId, forkId) {
+    return await this.sessionManager.exportFork(sessionId, forkId);
+  }
+  /**
+   * Generate fork export with summary
+   *
+   * Sends a prompt to Claude requesting:
+   * 1. Generate executive summary of the conversation
+   * 2. Export using /export to the specified path
+   *
+   * IMPORTANT: This method is async but returns immediately.
+   * Claude will execute tasks in the background. Wait a few seconds before calling merge().
+   *
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   * @returns Path where Claude will save the export
+   */
+  async generateForkExport(sessionId, forkId) {
+    return await this.sessionManager.generateForkExport(sessionId, forkId);
+  }
+  /**
+   * Merge a fork to main
+   *
+   * PREREQUISITE: You must call generateForkExport() first and wait for Claude to complete
+   *
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   */
+  async merge(sessionId, forkId) {
+    await this.sessionManager.mergeFork(sessionId, forkId);
+  }
+  /**
+   * Generate export and merge a fork to main (recommended method)
+   *
+   * Workflow:
+   * 1. Generates export with summary (Claude does the work)
+   * 2. Wait for the file to be created
+   * 3. Merge to main
+   *
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   * @param waitTime Wait time in ms for Claude to complete (default: 15000)
+   */
+  async generateExportAndMerge(sessionId, forkId, waitTime = 15e3) {
+    await this.generateForkExport(sessionId, forkId);
+    logger.info(`Waiting ${waitTime}ms for Claude to complete export...`);
+    await new Promise((resolve) => setTimeout(resolve, waitTime));
+    await this.merge(sessionId, forkId);
+  }
+  /**
+   * Generate export, merge and close a fork (complete flow)
+   *
+   * @param sessionId Session ID
+   * @param forkId Fork ID
+   * @param waitTime Wait time in ms for Claude to complete (default: 15000)
+   */
+  async generateExportMergeAndClose(sessionId, forkId, waitTime = 15e3) {
+    await this.generateExportAndMerge(sessionId, forkId, waitTime);
+  }
+  /**
+   * Export and merge a fork to main (old method)
+   * @deprecated Usa generateExportAndMerge() en su lugar
+   */
+  async exportAndMerge(sessionId, forkId) {
+    await this.export(sessionId, forkId);
+    await this.merge(sessionId, forkId);
+  }
+  /**
+   * Export, merge and close a fork (old method)
+   * @deprecated Usa generateExportMergeAndClose() en su lugar
+   */
+  async mergeAndClose(sessionId, forkId) {
+    await this.exportAndMerge(sessionId, forkId);
+    await this.closeFork(sessionId, forkId);
+  }
+};
+
+// electron/main/main.ts
+import chokidar from "chokidar";
+import execa2 from "execa";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+var windows = /* @__PURE__ */ new Map();
+var currentSessionId = null;
+var currentProjectPath = null;
+function createWindow(sessionId, projectPath) {
+  if (windows.has(projectPath)) {
+    const existingWindow = windows.get(projectPath);
+    existingWindow.focus();
+    return existingWindow;
+  }
+  const projectName = path5.basename(projectPath);
+  const mainWindow = new BrowserWindow({
+    width: 600,
+    height: 800,
+    minWidth: 500,
+    minHeight: 600,
+    frame: false,
+    transparent: true,
+    alwaysOnTop: true,
+    resizable: true,
+    title: `Claude Orka - ${projectName}`,
+    webPreferences: {
+      preload: path5.join(__dirname2, "../preload/preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  currentSessionId = sessionId;
+  currentProjectPath = projectPath;
+  if (process.env.NODE_ENV === "development") {
+    mainWindow.loadURL("http://localhost:5173");
+  } else {
+    const indexPath = path5.join(__dirname2, "../renderer/index.html");
+    mainWindow.loadFile(indexPath);
+  }
+  watchStateFile(projectPath, mainWindow);
+  windows.set(projectPath, mainWindow);
+  mainWindow.on("closed", () => {
+    windows.delete(projectPath);
+  });
+  return mainWindow;
+}
+function watchStateFile(projectPath, window) {
+  const statePath = path5.join(projectPath, ".claude-orka/state.json");
+  const watcher = chokidar.watch(statePath, {
+    persistent: true,
+    ignoreInitial: true
+  });
+  watcher.on("change", async () => {
+    try {
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      if (currentSessionId) {
+        const session = await orka.getSession(currentSessionId);
+        if (session) {
+          window.webContents.send("state-updated", session);
+        }
+      }
+    } catch (error) {
+      console.error("Error watching state file:", error);
+    }
+  });
+  window.on("closed", () => {
+    watcher.close();
+  });
+}
+ipcMain.handle("get-session", async () => {
+  if (!currentSessionId || !currentProjectPath) {
+    throw new Error("No active session");
+  }
+  const orka = new ClaudeOrka(currentProjectPath);
+  await orka.initialize();
+  const session = await orka.getSession(currentSessionId);
+  return session;
 });
-ipcMain.handle('export-fork', async (_, sessionId, forkId) => {
-    if (!currentProjectPath) {
-        throw new Error('No active project');
-    }
-    const orka = new ClaudeOrka(currentProjectPath);
-    await orka.initialize();
-    const summary = await orka.generateForkExport(sessionId, forkId);
-    return summary;
+ipcMain.handle("select-node", async (_, nodeId) => {
+  if (!currentSessionId || !currentProjectPath) {
+    throw new Error("No active session");
+  }
+  const orka = new ClaudeOrka(currentProjectPath);
+  await orka.initialize();
+  const session = await orka.getSession(currentSessionId);
+  if (!session) return;
+  let tmuxPaneId;
+  if (nodeId === "main") {
+    tmuxPaneId = session.main?.tmuxPaneId;
+  } else {
+    const fork = session.forks.find((f) => f.id === nodeId);
+    tmuxPaneId = fork?.tmuxPaneId;
+  }
+  if (tmuxPaneId) {
+    await execa2("tmux", ["select-pane", "-t", tmuxPaneId]);
+  }
 });
-ipcMain.handle('merge-fork', async (_, sessionId, forkId) => {
-    if (!currentProjectPath) {
-        throw new Error('No active project');
-    }
-    const orka = new ClaudeOrka(currentProjectPath);
-    await orka.initialize();
-    await orka.generateExportAndMerge(sessionId, forkId);
+ipcMain.handle("create-fork", async (_, sessionId, name, parentId) => {
+  if (!currentProjectPath) {
+    throw new Error("No active project");
+  }
+  const orka = new ClaudeOrka(currentProjectPath);
+  await orka.initialize();
+  const fork = await orka.createFork(sessionId, name, parentId);
+  return fork;
 });
-ipcMain.on('close-window', (event) => {
-    const window = BrowserWindow.fromWebContents(event.sender);
-    window?.close();
+ipcMain.handle("export-fork", async (_, sessionId, forkId) => {
+  if (!currentProjectPath) {
+    throw new Error("No active project");
+  }
+  const orka = new ClaudeOrka(currentProjectPath);
+  await orka.initialize();
+  const summary = await orka.generateForkExport(sessionId, forkId);
+  return summary;
 });
-// App lifecycle
-app.whenReady().then(() => {
-    // Get session ID and project path from command line args
-    const args = process.argv.slice(2);
-    const sessionIdIndex = args.indexOf('--session-id');
-    const projectPathIndex = args.indexOf('--project-path');
-    if (sessionIdIndex !== -1 && args[sessionIdIndex + 1]) {
-        const sessionId = args[sessionIdIndex + 1];
-        const projectPath = projectPathIndex !== -1 && args[projectPathIndex + 1]
-            ? args[projectPathIndex + 1]
-            : process.cwd();
-        createWindow(sessionId, projectPath);
-    }
-    app.on('activate', () => {
-        if (BrowserWindow.getAllWindows().length === 0) {
-            // Don't create window on activate if no session
+ipcMain.handle("merge-fork", async (_, sessionId, forkId) => {
+  if (!currentProjectPath) {
+    throw new Error("No active project");
+  }
+  const orka = new ClaudeOrka(currentProjectPath);
+  await orka.initialize();
+  await orka.merge(sessionId, forkId);
+});
+ipcMain.handle("close-fork", async (_, sessionId, forkId) => {
+  if (!currentProjectPath) {
+    throw new Error("No active project");
+  }
+  const orka = new ClaudeOrka(currentProjectPath);
+  await orka.initialize();
+  await orka.closeFork(sessionId, forkId);
+});
+ipcMain.handle("open-export-file", async (_, exportPath) => {
+  if (!currentProjectPath) {
+    throw new Error("No active project");
+  }
+  const fullPath = path5.join(currentProjectPath, exportPath);
+  await shell.openPath(fullPath);
+});
+ipcMain.handle("open-project-folder", async () => {
+  if (!currentProjectPath) {
+    throw new Error("No active project");
+  }
+  try {
+    await execa2("cursor", [currentProjectPath]);
+    return;
+  } catch (error) {
+  }
+  try {
+    await execa2("code", [currentProjectPath]);
+    return;
+  } catch (error) {
+  }
+  await shell.openPath(currentProjectPath);
+});
+ipcMain.handle("focus-terminal", async () => {
+  const terminalApps = ["Terminal", "iTerm"];
+  for (const app2 of terminalApps) {
+    try {
+      await execa2("osascript", ["-e", `tell application "${app2}" to activate`]);
+      return;
+    } catch (error) {
+    }
+  }
+  try {
+    await execa2("open", ["-a", "Terminal"]);
+  } catch (error) {
+    console.error("Failed to open terminal:", error);
+  }
+});
+ipcMain.handle("save-and-close", async () => {
+  if (currentSessionId && currentProjectPath) {
+    try {
+      const orka = new ClaudeOrka(currentProjectPath);
+      await orka.initialize();
+      const session = await orka.getSession(currentSessionId);
+      if (session?.tmuxSessionId) {
+        console.log("Save and close: detaching from tmux session:", session.tmuxSessionId);
+        try {
+          await execa2("tmux", ["detach-client", "-s", session.tmuxSessionId]);
+          console.log("Detached from tmux session (session remains alive)");
+        } catch (error) {
+          console.log("Error detaching from tmux:", error);
         }
-    });
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        try {
+          await execa2("osascript", [
+            "-e",
+            `tell application "Terminal" to close (first window whose name contains "${session.tmuxSessionId}")`
+          ]);
+          console.log("Closed specific Terminal window");
+        } catch (error) {
+          console.log("Could not close specific window with AppleScript");
+          try {
+            const { stdout } = await execa2("osascript", [
+              "-e",
+              'tell application "Terminal" to count windows'
+            ]);
+            const windowCount = parseInt(stdout.trim());
+            if (windowCount === 1) {
+              await execa2("osascript", ["-e", 'tell application "Terminal" to quit']);
+              console.log("Quit Terminal (was last window)");
+            } else {
+              console.log("Multiple Terminal windows open, cannot close safely");
+            }
+          } catch (countError) {
+            console.log("Could not determine Terminal window count:", countError);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error in save-and-close:", error);
+    }
+  }
+  app.quit();
+});
+ipcMain.on("close-window", async (event) => {
+  const window = BrowserWindow.fromWebContents(event.sender);
+  window?.close();
 });
-app.on('window-all-closed', () => {
-    if (process.platform !== 'darwin') {
-        app.quit();
+app.whenReady().then(() => {
+  const args = process.argv.slice(2);
+  const sessionIdIndex = args.indexOf("--session-id");
+  const projectPathIndex = args.indexOf("--project-path");
+  if (sessionIdIndex !== -1 && args[sessionIdIndex + 1]) {
+    const sessionId = args[sessionIdIndex + 1];
+    const projectPath = projectPathIndex !== -1 && args[projectPathIndex + 1] ? args[projectPathIndex + 1] : process.cwd();
+    createWindow(sessionId, projectPath);
+  }
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
     }
+  });
+});
+app.on("window-all-closed", () => {
+  app.quit();
 });
-//# sourceMappingURL=main.js.map