@enruana/claude-orka 0.1.0 → 0.1.2

package/dist/cli.js

@@ -0,0 +1,2433 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/core/StateManager.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+
+// src/utils/tmux.ts
+import execa from "execa";
+
+// src/utils/logger.ts
+var Logger = class {
+  level = 1 /* INFO */;
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.log("[DEBUG]", ...args);
+    }
+  }
+  info(...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log("[INFO]", ...args);
+    }
+  }
+  warn(...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn("[WARN]", ...args);
+    }
+  }
+  error(...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error("[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 {
+          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 fs from "fs-extra";
+import os from "os";
+import path from "path";
+var CLAUDE_HISTORY_PATH = path.join(os.homedir(), ".claude", "history.jsonl");
+async function readClaudeHistory() {
+  try {
+    const exists = await fs.pathExists(CLAUDE_HISTORY_PATH);
+    if (!exists) {
+      logger.warn(`Claude history file not found: ${CLAUDE_HISTORY_PATH}`);
+      return [];
+    }
+    const content = await fs.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 = path2.resolve(projectPath);
+    this.orkaDir = path2.join(this.projectPath, ".claude-orka");
+    this.statePath = path2.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 fs2.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 fs2.ensureDir(this.orkaDir);
+    logger.debug("Directories ensured");
+  }
+  /**
+   * Read current state
+   */
+  async read() {
+    try {
+      const content = await fs2.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 fs2.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 = path2.join(this.projectPath, contextPath);
+    await fs2.writeFile(fullPath, content, "utf-8");
+    logger.info(`Context saved: ${contextPath}`);
+    return contextPath;
+  }
+  /**
+   * Leer un contexto desde archivo
+   */
+  async readContext(contextPath) {
+    const fullPath = path2.join(this.projectPath, contextPath);
+    if (!await fs2.pathExists(fullPath)) {
+      throw new Error(`Context file not found: ${contextPath}`);
+    }
+    return await fs2.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 path3 from "path";
+import fs3 from "fs-extra";
+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
+    });
+    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})`);
+    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}`;
+    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
+    });
+    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}`);
+    return session;
+  }
+  /**
+   * 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`);
+    }
+    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 (session.tmuxSessionId) {
+      await TmuxCommands.killSession(session.tmuxSessionId);
+    }
+    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, 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} in session ${session.name}`);
+    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: session.main.claudeSessionId,
+      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,
+      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`);
+    }
+    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 = "saved";
+    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 = path3.join(this.projectPath, ".claude-orka", "exports");
+    await fs3.ensureDir(exportsDir);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const exportName = `fork-${fork.name}-${timestamp}.md`;
+    const relativeExportPath = `.claude-orka/exports/${exportName}`;
+    const prompt = `
+Please generate a complete summary of this fork conversation "${fork.name}" and save it to the file:
+\`${relativeExportPath}\`
+
+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. Path: ${relativeExportPath}`);
+    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."
+      );
+    }
+    logger.info(`Merging fork ${fork.name} to main`);
+    const fullPath = path3.join(this.projectPath, fork.contextPath);
+    const exists = await fs3.pathExists(fullPath);
+    if (!exists) {
+      throw new Error(
+        `Export file not found: ${fork.contextPath}. Make sure generateForkExport() completed.`
+      );
+    }
+    const mergePrompt = `
+I have completed work on the fork "${fork.name}".
+Please read the file \`${fork.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 main conversation.
+`.trim();
+    if (!session.main.tmuxPaneId) {
+      throw new Error("Main pane is not active. Cannot send merge command.");
+    }
+    await TmuxCommands.sendKeys(session.main.tmuxPaneId, mergePrompt);
+    await TmuxCommands.sendEnter(session.main.tmuxPaneId);
+    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);
+  }
+};
+
+// src/core/ClaudeOrka.ts
+var ClaudeOrka = class {
+  sessionManager;
+  /**
+   * Create a ClaudeOrka instance
+   * @param projectPath Absolute path to the project
+   */
+  constructor(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 vertical Whether to split vertically (default: false = horizontal)
+   * @returns Created fork
+   */
+  async createFork(sessionId, name, vertical) {
+    return await this.sessionManager.createFork(sessionId, name, 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);
+  }
+};
+
+// src/cli/utils/output.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+var Output = class {
+  /**
+   * Success message
+   */
+  static success(message) {
+    console.log(chalk.green("\u2713"), message);
+  }
+  /**
+   * Error message
+   */
+  static error(message) {
+    console.error(chalk.red("\u2717"), message);
+  }
+  /**
+   * Warning message
+   */
+  static warn(message) {
+    console.warn(chalk.yellow("\u26A0"), message);
+  }
+  /**
+   * Info message
+   */
+  static info(message) {
+    console.log(chalk.blue("\u2139"), message);
+  }
+  /**
+   * Header
+   */
+  static header(message) {
+    console.log("\n" + chalk.bold.cyan(message));
+    console.log(chalk.gray("\u2500".repeat(message.length)));
+  }
+  /**
+   * Section
+   */
+  static section(title) {
+    console.log("\n" + chalk.bold(title));
+  }
+  /**
+   * Display session details
+   */
+  static session(session) {
+    const statusColor = session.status === "active" ? chalk.green : chalk.yellow;
+    const statusEmoji = session.status === "active" ? "\u2713" : "\u{1F4BE}";
+    console.log(`
+${statusEmoji} ${chalk.bold(session.name)}`);
+    console.log(`  ${chalk.gray("ID:")} ${session.id}`);
+    console.log(`  ${chalk.gray("Claude Session:")} ${session.main.claudeSessionId}`);
+    console.log(`  ${chalk.gray("Status:")} ${statusColor(session.status)}`);
+    console.log(`  ${chalk.gray("Created:")} ${new Date(session.createdAt).toLocaleString()}`);
+    console.log(`  ${chalk.gray("Last Activity:")} ${new Date(session.lastActivity).toLocaleString()}`);
+    if (session.status === "active") {
+      console.log(`  ${chalk.gray("Tmux Session:")} ${session.tmuxSessionId}`);
+    }
+    if (session.forks.length > 0) {
+      console.log(`  ${chalk.gray("Forks:")} ${session.forks.length}`);
+      console.log(
+        `    ${chalk.green("Active:")} ${session.forks.filter((f) => f.status === "active").length}`
+      );
+      console.log(
+        `    ${chalk.yellow("Saved:")} ${session.forks.filter((f) => f.status === "saved").length}`
+      );
+      console.log(
+        `    ${chalk.blue("Merged:")} ${session.forks.filter((f) => f.status === "merged").length}`
+      );
+    }
+  }
+  /**
+   * Display fork details
+   */
+  static fork(fork) {
+    const statusColor = fork.status === "active" ? chalk.green : fork.status === "merged" ? chalk.blue : chalk.yellow;
+    const statusEmoji = fork.status === "active" ? "\u2713" : fork.status === "merged" ? "\u{1F500}" : "\u{1F4BE}";
+    console.log(`
+  ${statusEmoji} ${chalk.bold(fork.name)}`);
+    console.log(`    ${chalk.gray("ID:")} ${fork.id}`);
+    console.log(`    ${chalk.gray("Claude Session:")} ${fork.claudeSessionId}`);
+    console.log(`    ${chalk.gray("Status:")} ${statusColor(fork.status)}`);
+    console.log(`    ${chalk.gray("Created:")} ${new Date(fork.createdAt).toLocaleString()}`);
+    if (fork.status === "active" && fork.tmuxPaneId) {
+      console.log(`    ${chalk.gray("Tmux Pane:")} ${fork.tmuxPaneId}`);
+    }
+    if (fork.contextPath) {
+      console.log(`    ${chalk.gray("Export:")} ${fork.contextPath}`);
+    }
+    if (fork.mergedToMain && fork.mergedAt) {
+      console.log(
+        `    ${chalk.gray("Merged:")} ${new Date(fork.mergedAt).toLocaleString()}`
+      );
+    }
+  }
+  /**
+   * Display sessions table
+   */
+  static sessionsTable(sessions) {
+    if (sessions.length === 0) {
+      this.warn("No sessions found");
+      return;
+    }
+    const table = new Table({
+      head: [
+        chalk.bold("Name"),
+        chalk.bold("Status"),
+        chalk.bold("Forks"),
+        chalk.bold("Created"),
+        chalk.bold("ID")
+      ],
+      colWidths: [25, 12, 20, 20, 40]
+    });
+    for (const session of sessions) {
+      const statusColor = session.status === "active" ? chalk.green : chalk.yellow;
+      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;
+      table.push([
+        session.name,
+        statusColor(session.status),
+        `${chalk.green(activeForks)}/${chalk.yellow(savedForks)}/${chalk.blue(mergedForks)}`,
+        new Date(session.createdAt).toLocaleDateString(),
+        chalk.gray(session.id.substring(0, 8) + "...")
+      ]);
+    }
+    console.log(table.toString());
+  }
+  /**
+   * Display forks table
+   */
+  static forksTable(forks) {
+    if (forks.length === 0) {
+      this.warn("No forks found");
+      return;
+    }
+    const table = new Table({
+      head: [
+        chalk.bold("Name"),
+        chalk.bold("Status"),
+        chalk.bold("Export"),
+        chalk.bold("Created"),
+        chalk.bold("ID")
+      ],
+      colWidths: [25, 12, 15, 20, 40]
+    });
+    for (const fork of forks) {
+      const statusColor = fork.status === "active" ? chalk.green : fork.status === "merged" ? chalk.blue : chalk.yellow;
+      const hasExport = fork.contextPath ? chalk.green("\u2713") : chalk.gray("\u2717");
+      table.push([
+        fork.name,
+        statusColor(fork.status),
+        hasExport,
+        new Date(fork.createdAt).toLocaleDateString(),
+        chalk.gray(fork.id.substring(0, 8) + "...")
+      ]);
+    }
+    console.log(table.toString());
+  }
+  /**
+   * Display project summary
+   */
+  static projectSummary(summary) {
+    this.header("\u{1F4CA} Project Summary");
+    console.log(`
+${chalk.gray("Project Path:")} ${summary.projectPath}`);
+    console.log(`${chalk.gray("Total Sessions:")} ${summary.totalSessions}`);
+    console.log(`  ${chalk.green("Active:")} ${summary.activeSessions}`);
+    console.log(`  ${chalk.yellow("Saved:")} ${summary.savedSessions}`);
+    console.log(
+      `${chalk.gray("Last Updated:")} ${new Date(summary.lastUpdated).toLocaleString()}`
+    );
+    if (summary.sessions.length === 0) {
+      console.log("\n" + chalk.gray("No sessions available"));
+      return;
+    }
+    this.section("\n\u{1F4DD} Sessions:");
+    for (const session of summary.sessions) {
+      const statusEmoji = session.status === "active" ? "\u2713" : "\u{1F4BE}";
+      const statusColor = session.status === "active" ? chalk.green : chalk.yellow;
+      console.log(`
+${statusEmoji} ${chalk.bold(session.name)}`);
+      console.log(`  ${chalk.gray("ID:")} ${session.id}`);
+      console.log(`  ${chalk.gray("Claude Session:")} ${session.claudeSessionId}`);
+      console.log(`  ${chalk.gray("Status:")} ${statusColor(session.status)}`);
+      console.log(
+        `  ${chalk.gray("Created:")} ${new Date(session.createdAt).toLocaleString()}`
+      );
+      console.log(
+        `  ${chalk.gray("Last Activity:")} ${new Date(session.lastActivity).toLocaleString()}`
+      );
+      console.log(`  ${chalk.gray("Total Forks:")} ${session.totalForks}`);
+      console.log(
+        `    ${chalk.green("Active:")} ${session.activeForks} | ${chalk.yellow("Saved:")} ${session.savedForks} | ${chalk.blue("Merged:")} ${session.mergedForks}`
+      );
+      if (session.forks.length > 0) {
+        console.log(`
+  ${chalk.bold("Forks:")}`);
+        for (const fork of session.forks) {
+          const forkEmoji = fork.status === "active" ? "\u2713" : fork.status === "merged" ? "\u{1F500}" : "\u{1F4BE}";
+          const forkColor = fork.status === "active" ? chalk.green : fork.status === "merged" ? chalk.blue : chalk.yellow;
+          console.log(`
+    ${forkEmoji} ${chalk.bold(fork.name)}`);
+          console.log(`      ${chalk.gray("ID:")} ${fork.id}`);
+          console.log(`      ${chalk.gray("Claude Session:")} ${fork.claudeSessionId}`);
+          console.log(`      ${chalk.gray("Status:")} ${forkColor(fork.status)}`);
+          console.log(
+            `      ${chalk.gray("Created:")} ${new Date(fork.createdAt).toLocaleString()}`
+          );
+          if (fork.hasContext) {
+            console.log(`      ${chalk.gray("Export:")} ${chalk.green("\u2713")} ${fork.contextPath}`);
+          }
+          if (fork.mergedToMain && fork.mergedAt) {
+            console.log(
+              `      ${chalk.gray("Merged:")} ${new Date(fork.mergedAt).toLocaleString()}`
+            );
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Display JSON output
+   */
+  static json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+  /**
+   * Display empty line
+   */
+  static newline() {
+    console.log();
+  }
+};
+
+// src/cli/utils/errors.ts
+import chalk2 from "chalk";
+import fs4 from "fs";
+import path4 from "path";
+var CLIError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CLIError";
+  }
+};
+function handleError(error) {
+  if (error instanceof CLIError) {
+    Output.error(error.message);
+    process.exit(error.exitCode);
+  }
+  if (error instanceof Error) {
+    Output.error(`Unexpected error: ${error.message}`);
+    console.error(chalk2.gray(error.stack));
+    process.exit(1);
+  }
+  Output.error("An unknown error occurred");
+  process.exit(1);
+}
+function validateSessionId(sessionId) {
+  if (!sessionId || sessionId.length === 0) {
+    throw new CLIError("Session ID is required");
+  }
+}
+function validateForkId(forkId) {
+  if (!forkId || forkId.length === 0) {
+    throw new CLIError("Fork ID is required");
+  }
+}
+function validateInitialized(projectPath) {
+  const orkaDir = path4.join(projectPath, ".claude-orka");
+  if (!fs4.existsSync(orkaDir)) {
+    throw new CLIError(
+      'Project not initialized. Run "orka init" first.',
+      2
+    );
+  }
+}
+
+// src/cli/commands/init.ts
+function initCommand(program2) {
+  program2.command("init").description("Initialize Claude-Orka in the current project").action(async () => {
+    try {
+      const projectPath = process.cwd();
+      Output.info(`Initializing Claude-Orka in: ${projectPath}`);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      Output.success("Claude-Orka initialized successfully!");
+      Output.info("You can now create sessions with: orka session create");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/status.ts
+function statusCommand(program2) {
+  program2.command("status").description("Show project status and all sessions").option("-j, --json", "Output as JSON").action(async (options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const summary = await orka.getProjectSummary();
+      if (options.json) {
+        Output.json(summary);
+      } else {
+        Output.projectSummary(summary);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/session.ts
+import ora from "ora";
+function sessionCommand(program2) {
+  const session = program2.command("session").description("Manage Claude sessions");
+  session.command("create [name]").description("Create a new Claude session").option("--no-terminal", "Do not open terminal window").action(async (name, options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora("Creating session...").start();
+      const newSession = await orka.createSession(name, options.terminal);
+      spinner.succeed("Session created!");
+      Output.session(newSession);
+      Output.newline();
+      Output.info(`You can now interact with Claude in the tmux window.`);
+      Output.info(`To create a fork: orka fork create ${newSession.id}`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  session.command("list").description("List all sessions").option("-s, --status <status>", "Filter by status (active, saved)").option("-j, --json", "Output as JSON").action(async (options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const filters = options.status ? { status: options.status } : void 0;
+      const sessions = await orka.listSessions(filters);
+      if (options.json) {
+        Output.json(sessions);
+      } else {
+        Output.header("\u{1F4CB} Sessions");
+        Output.sessionsTable(sessions);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  session.command("get <session-id>").description("Get session details").option("-j, --json", "Output as JSON").action(async (sessionId, options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const session2 = await orka.getSession(sessionId);
+      if (!session2) {
+        Output.error(`Session not found: ${sessionId}`);
+        process.exit(1);
+      }
+      if (options.json) {
+        Output.json(session2);
+      } else {
+        Output.session(session2);
+        if (session2.forks.length > 0) {
+          Output.section("\n\u{1F33F} Forks:");
+          for (const fork of session2.forks) {
+            Output.fork(fork);
+          }
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  session.command("resume <session-id>").description("Resume a saved session").option("--no-terminal", "Do not open terminal window").action(async (sessionId, options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora("Resuming session...").start();
+      const resumedSession = await orka.resumeSession(sessionId, options.terminal);
+      spinner.succeed("Session resumed!");
+      Output.session(resumedSession);
+      Output.newline();
+      Output.info("Session and all saved forks have been restored.");
+      Output.info("Claude will remember the context of all conversations.");
+      if (resumedSession.forks.length > 0) {
+        const activeForks = resumedSession.forks.filter((f) => f.status === "active");
+        if (activeForks.length > 0) {
+          Output.newline();
+          Output.section("Restored forks:");
+          for (const fork of activeForks) {
+            Output.fork(fork);
+          }
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  session.command("close <session-id>").description("Close a session (saves it for later)").action(async (sessionId) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora("Closing session...").start();
+      await orka.closeSession(sessionId);
+      spinner.succeed("Session closed!");
+      Output.info("Session has been saved. You can resume it later with:");
+      Output.info(`  orka session resume ${sessionId}`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  session.command("delete <session-id>").description("Permanently delete a session").action(async (sessionId) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora("Deleting session...").start();
+      await orka.deleteSession(sessionId);
+      spinner.succeed("Session deleted!");
+      Output.warn("Session has been permanently deleted.");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/fork.ts
+import ora2 from "ora";
+function forkCommand(program2) {
+  const fork = program2.command("fork").description("Manage conversation forks");
+  fork.command("create <session-id> [name]").description("Create a new fork in a session").option("-v, --vertical", "Split vertically instead of horizontally").action(async (sessionId, name, options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora2("Creating fork...").start();
+      spinner.text = "Creating fork and detecting session ID...";
+      const newFork = await orka.createFork(sessionId, name, options.vertical);
+      spinner.succeed("Fork created!");
+      Output.fork(newFork);
+      Output.newline();
+      Output.info("Fork created in a new tmux pane.");
+      Output.info("You can now explore an alternative approach in this fork.");
+      Output.newline();
+      Output.info(`To merge this fork: orka merge ${sessionId} ${newFork.id}`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  fork.command("list <session-id>").description("List all forks in a session").option("-s, --status <status>", "Filter by status (active, saved, merged)").option("-j, --json", "Output as JSON").action(async (sessionId, options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const session = await orka.getSession(sessionId);
+      if (!session) {
+        Output.error(`Session not found: ${sessionId}`);
+        process.exit(1);
+      }
+      let forks = session.forks;
+      if (options.status) {
+        forks = forks.filter((f) => f.status === options.status);
+      }
+      if (options.json) {
+        Output.json(forks);
+      } else {
+        Output.header(`\u{1F33F} Forks in ${session.name}`);
+        Output.forksTable(forks);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  fork.command("resume <session-id> <fork-id>").description("Resume a saved fork").action(async (sessionId, forkId) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      validateForkId(forkId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora2("Resuming fork...").start();
+      const resumedFork = await orka.resumeFork(sessionId, forkId);
+      spinner.succeed("Fork resumed!");
+      Output.fork(resumedFork);
+      Output.newline();
+      Output.info("Fork has been restored in a new tmux pane.");
+      Output.info("Claude will remember the context of this conversation.");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  fork.command("close <session-id> <fork-id>").description("Close a fork (saves it for later)").action(async (sessionId, forkId) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      validateForkId(forkId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora2("Closing fork...").start();
+      await orka.closeFork(sessionId, forkId);
+      spinner.succeed("Fork closed!");
+      Output.info("Fork has been saved. You can resume it later with:");
+      Output.info(`  orka fork resume ${sessionId} ${forkId}`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  fork.command("delete <session-id> <fork-id>").description("Permanently delete a fork").action(async (sessionId, forkId) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      validateForkId(forkId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora2("Deleting fork...").start();
+      await orka.deleteFork(sessionId, forkId);
+      spinner.succeed("Fork deleted!");
+      Output.warn("Fork has been permanently deleted.");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/merge.ts
+import ora3 from "ora";
+function mergeCommand(program2) {
+  const merge = program2.command("merge").description("Merge and export operations");
+  merge.command("export <session-id> <fork-id>").description("Generate export summary for a fork").action(async (sessionId, forkId) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      validateForkId(forkId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      Output.info("Generating export summary...");
+      Output.warn("This will send a prompt to Claude to generate a summary.");
+      Output.warn("Wait for Claude to finish before running the merge command.");
+      const exportPath = await orka.generateForkExport(sessionId, forkId);
+      Output.success("Export prompt sent to Claude!");
+      Output.info(`Export will be saved to: ${exportPath}`);
+      Output.newline();
+      Output.info("Next steps:");
+      Output.info("  1. Wait for Claude to generate and save the summary (~15-30 seconds)");
+      Output.info("  2. Run: orka merge do " + sessionId + " " + forkId);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  merge.command("do <session-id> <fork-id>").description("Merge a fork to main (requires export first)").action(async (sessionId, forkId) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      validateForkId(forkId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const spinner = ora3("Merging fork to main...").start();
+      await orka.merge(sessionId, forkId);
+      spinner.succeed("Fork merged to main!");
+      Output.info("The fork context has been sent to the main conversation.");
+      Output.info("Claude in main now has access to the fork exploration.");
+      Output.warn("Fork has been closed and marked as merged.");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  merge.command("auto <session-id> <fork-id>").description("Generate export and merge automatically").option("-w, --wait <ms>", "Wait time in milliseconds for Claude to complete export", "15000").action(async (sessionId, forkId, options) => {
+    try {
+      const projectPath = process.cwd();
+      validateInitialized(projectPath);
+      validateSessionId(sessionId);
+      validateForkId(forkId);
+      const orka = new ClaudeOrka(projectPath);
+      await orka.initialize();
+      const waitTime = parseInt(options.wait);
+      Output.info("Starting automatic export and merge...");
+      const spinner = ora3("Generating export summary...").start();
+      await orka.generateExportAndMerge(sessionId, forkId, waitTime);
+      spinner.succeed("Fork merged to main!");
+      Output.info("The fork context has been sent to the main conversation.");
+      Output.info("Claude in main now has access to the fork exploration.");
+      Output.warn("Fork has been closed and marked as merged.");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/doctor.ts
+import execa2 from "execa";
+import fs5 from "fs-extra";
+import path5 from "path";
+import chalk3 from "chalk";
+function doctorCommand(program2) {
+  program2.command("doctor").description("Check system dependencies and configuration").action(async () => {
+    try {
+      console.log(chalk3.bold.cyan("\n\u{1F50D} Claude-Orka Doctor\n"));
+      console.log("Checking system dependencies and configuration...\n");
+      const results = [];
+      results.push(await checkNodeVersion());
+      results.push(await checkTmux());
+      results.push(await checkClaude());
+      results.push(await checkProjectInit());
+      results.push(await checkWritePermissions());
+      results.push(await checkClaudeDir());
+      displayResults(results);
+      const criticalFailures = results.filter((r) => r.status === "fail");
+      if (criticalFailures.length > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function checkNodeVersion() {
+  try {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split(".")[0]);
+    if (major >= 18) {
+      return {
+        name: "Node.js",
+        status: "pass",
+        message: `${version} (>= 18.0.0)`
+      };
+    } else {
+      return {
+        name: "Node.js",
+        status: "fail",
+        message: `${version} (requires >= 18.0.0)`,
+        fix: "Install Node.js 18 or higher from https://nodejs.org"
+      };
+    }
+  } catch (error) {
+    return {
+      name: "Node.js",
+      status: "fail",
+      message: "Not found",
+      fix: "Install Node.js from https://nodejs.org"
+    };
+  }
+}
+async function checkTmux() {
+  try {
+    const { stdout } = await execa2("tmux", ["-V"]);
+    const version = stdout.trim();
+    return {
+      name: "tmux",
+      status: "pass",
+      message: version
+    };
+  } catch (error) {
+    return {
+      name: "tmux",
+      status: "fail",
+      message: "Not found",
+      details: "tmux is required for session management",
+      fix: "Install tmux:\n  macOS: brew install tmux\n  Ubuntu: sudo apt-get install tmux"
+    };
+  }
+}
+async function checkClaude() {
+  try {
+    const { stdout } = await execa2("claude", ["--version"]);
+    const version = stdout.trim();
+    return {
+      name: "Claude CLI",
+      status: "pass",
+      message: version
+    };
+  } catch (error) {
+    return {
+      name: "Claude CLI",
+      status: "fail",
+      message: "Not found",
+      details: "Claude CLI is required for AI sessions",
+      fix: "Install Claude CLI from https://claude.ai/download"
+    };
+  }
+}
+async function checkProjectInit() {
+  const projectPath = process.cwd();
+  const orkaDir = path5.join(projectPath, ".claude-orka");
+  const stateFile = path5.join(orkaDir, "state.json");
+  try {
+    const dirExists = await fs5.pathExists(orkaDir);
+    const stateExists = await fs5.pathExists(stateFile);
+    if (dirExists && stateExists) {
+      return {
+        name: "Project initialization",
+        status: "pass",
+        message: "Initialized",
+        details: ".claude-orka/ directory and state.json found"
+      };
+    } else if (dirExists) {
+      return {
+        name: "Project initialization",
+        status: "warn",
+        message: "Partially initialized",
+        details: ".claude-orka/ exists but state.json is missing",
+        fix: "Run: orka init"
+      };
+    } else {
+      return {
+        name: "Project initialization",
+        status: "warn",
+        message: "Not initialized",
+        details: "Project is not initialized",
+        fix: "Run: orka init"
+      };
+    }
+  } catch (error) {
+    return {
+      name: "Project initialization",
+      status: "fail",
+      message: "Error checking",
+      details: error.message
+    };
+  }
+}
+async function checkWritePermissions() {
+  const projectPath = process.cwd();
+  try {
+    const testFile = path5.join(projectPath, ".claude-orka-write-test");
+    await fs5.writeFile(testFile, "test");
+    await fs5.remove(testFile);
+    return {
+      name: "Write permissions",
+      status: "pass",
+      message: "OK",
+      details: "Can write to project directory"
+    };
+  } catch (error) {
+    return {
+      name: "Write permissions",
+      status: "fail",
+      message: "Cannot write",
+      details: `No write permission in ${projectPath}`,
+      fix: "Check directory permissions"
+    };
+  }
+}
+async function checkClaudeDir() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  const claudeDir = path5.join(homeDir, ".claude");
+  const historyFile = path5.join(claudeDir, "history.jsonl");
+  try {
+    const dirExists = await fs5.pathExists(claudeDir);
+    const historyExists = await fs5.pathExists(historyFile);
+    if (dirExists && historyExists) {
+      return {
+        name: "Claude directory",
+        status: "pass",
+        message: "Found",
+        details: `~/.claude/history.jsonl exists`
+      };
+    } else if (dirExists) {
+      return {
+        name: "Claude directory",
+        status: "warn",
+        message: "History file missing",
+        details: "~/.claude/ exists but history.jsonl not found",
+        fix: "Run Claude CLI at least once to create history"
+      };
+    } else {
+      return {
+        name: "Claude directory",
+        status: "warn",
+        message: "Not found",
+        details: "~/.claude/ directory not found",
+        fix: "Run Claude CLI at least once to create the directory"
+      };
+    }
+  } catch (error) {
+    return {
+      name: "Claude directory",
+      status: "fail",
+      message: "Error checking",
+      details: error.message
+    };
+  }
+}
+function displayResults(results) {
+  console.log(chalk3.bold("Results:\n"));
+  for (const result of results) {
+    let icon;
+    let color;
+    switch (result.status) {
+      case "pass":
+        icon = "\u2713";
+        color = chalk3.green;
+        break;
+      case "warn":
+        icon = "\u26A0";
+        color = chalk3.yellow;
+        break;
+      case "fail":
+        icon = "\u2717";
+        color = chalk3.red;
+        break;
+    }
+    console.log(
+      `${color(icon)} ${chalk3.bold(result.name)}: ${color(result.message)}`
+    );
+    if (result.details) {
+      console.log(`  ${chalk3.gray(result.details)}`);
+    }
+    if (result.fix) {
+      console.log(`  ${chalk3.cyan("Fix:")} ${result.fix}`);
+    }
+    console.log();
+  }
+  const passed = results.filter((r) => r.status === "pass").length;
+  const warned = results.filter((r) => r.status === "warn").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  console.log(chalk3.bold("Summary:"));
+  console.log(`  ${chalk3.green("\u2713")} Passed: ${passed}`);
+  console.log(`  ${chalk3.yellow("\u26A0")} Warnings: ${warned}`);
+  console.log(`  ${chalk3.red("\u2717")} Failed: ${failed}`);
+  console.log();
+  if (failed === 0 && warned === 0) {
+    Output.success("All checks passed! Claude-Orka is ready to use.");
+  } else if (failed === 0) {
+    Output.warn("Some warnings found. Claude-Orka should work but check the warnings above.");
+  } else {
+    Output.error("Some critical checks failed. Fix the errors above before using Claude-Orka.");
+  }
+}
+
+// src/cli/commands/prepare.ts
+import execa3 from "execa";
+import chalk4 from "chalk";
+import ora4 from "ora";
+function prepareCommand(program2) {
+  program2.command("prepare").description("Install and configure system dependencies").option("-y, --yes", "Skip confirmation prompts").action(async (options) => {
+    try {
+      console.log(chalk4.bold.cyan("\n\u{1F527} Claude-Orka Preparation\n"));
+      console.log("This will help you install required dependencies:\n");
+      console.log("  \u2022 tmux (terminal multiplexer)");
+      console.log("  \u2022 Claude CLI (if needed)\n");
+      if (!options.yes) {
+        const readline = __require("readline").createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        const answer = await new Promise((resolve) => {
+          readline.question("Continue? (y/n): ", resolve);
+        });
+        readline.close();
+        if (answer.toLowerCase() !== "y") {
+          Output.warn("Installation cancelled");
+          return;
+        }
+      }
+      const system = await detectSystem();
+      console.log(chalk4.gray(`
+Detected: ${system.platform}`));
+      await installTmux(system);
+      await checkClaudeCLI();
+      console.log(chalk4.bold.green("\n\u2713 Preparation complete!\n"));
+      console.log("Run " + chalk4.cyan("orka doctor") + " to verify everything is working.");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+async function detectSystem() {
+  const platform = process.platform;
+  const info = { platform };
+  if (platform === "darwin") {
+    try {
+      await execa3("which", ["brew"]);
+      info.hasHomebrew = true;
+      info.packageManager = "brew";
+    } catch {
+      info.hasHomebrew = false;
+    }
+  } else if (platform === "linux") {
+    try {
+      await execa3("which", ["apt-get"]);
+      info.hasApt = true;
+      info.packageManager = "apt";
+    } catch {
+      try {
+        await execa3("which", ["yum"]);
+        info.hasYum = true;
+        info.packageManager = "yum";
+      } catch {
+      }
+    }
+  }
+  return info;
+}
+async function installTmux(system) {
+  console.log(chalk4.bold("\n\u{1F4E6} Installing tmux...\n"));
+  try {
+    await execa3("which", ["tmux"]);
+    const { stdout } = await execa3("tmux", ["-V"]);
+    Output.success(`tmux is already installed: ${stdout}`);
+    return;
+  } catch {
+  }
+  const spinner = ora4("Installing tmux...").start();
+  try {
+    if (system.platform === "darwin") {
+      if (!system.hasHomebrew) {
+        spinner.fail("Homebrew is not installed");
+        console.log(chalk4.yellow("\nPlease install Homebrew first:"));
+        console.log(
+          chalk4.cyan(
+            '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'
+          )
+        );
+        console.log("\nThen run: " + chalk4.cyan("brew install tmux"));
+        return;
+      }
+      await execa3("brew", ["install", "tmux"]);
+      spinner.succeed("tmux installed via Homebrew");
+    } else if (system.platform === "linux") {
+      if (system.hasApt) {
+        await execa3("sudo", ["apt-get", "update"]);
+        await execa3("sudo", ["apt-get", "install", "-y", "tmux"]);
+        spinner.succeed("tmux installed via apt");
+      } else if (system.hasYum) {
+        await execa3("sudo", ["yum", "install", "-y", "tmux"]);
+        spinner.succeed("tmux installed via yum");
+      } else {
+        spinner.fail("Unknown package manager");
+        console.log(chalk4.yellow("\nPlease install tmux manually:"));
+        console.log(chalk4.cyan("  https://github.com/tmux/tmux/wiki/Installing"));
+      }
+    } else {
+      spinner.fail(`Unsupported platform: ${system.platform}`);
+      console.log(chalk4.yellow("\nPlease install tmux manually:"));
+      console.log(chalk4.cyan("  https://github.com/tmux/tmux/wiki/Installing"));
+    }
+  } catch (error) {
+    spinner.fail("Failed to install tmux");
+    console.log(chalk4.red(`
+Error: ${error.message}`));
+    console.log(chalk4.yellow("\nPlease install tmux manually:"));
+    console.log(chalk4.cyan("  macOS: brew install tmux"));
+    console.log(chalk4.cyan("  Ubuntu: sudo apt-get install tmux"));
+    console.log(chalk4.cyan("  CentOS: sudo yum install tmux"));
+  }
+}
+async function checkClaudeCLI() {
+  console.log(chalk4.bold("\n\u{1F916} Checking Claude CLI...\n"));
+  try {
+    const { stdout } = await execa3("claude", ["--version"]);
+    Output.success(`Claude CLI is installed: ${stdout}`);
+  } catch {
+    Output.warn("Claude CLI is not installed");
+    console.log(chalk4.yellow("\nClaude CLI is required for Claude-Orka to work."));
+    console.log(chalk4.cyan("\nInstallation options:"));
+    console.log("  1. Visit: https://claude.ai/download");
+    console.log("  2. Or use npm: npm install -g @anthropic-ai/claude-cli");
+    console.log(
+      chalk4.gray("\nNote: You may need to restart your terminal after installation.")
+    );
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("orka").description("Claude-Orka: Orchestrate Claude Code sessions with tmux").version("1.0.0");
+prepareCommand(program);
+initCommand(program);
+doctorCommand(program);
+statusCommand(program);
+sessionCommand(program);
+forkCommand(program);
+mergeCommand(program);
+program.parse();