mexus-cli 1.0.0

package/packages/server/dist/cli.mjs

@@ -0,0 +1,3186 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/workspace/ConfigManager.ts
+var ConfigManager_exports = {};
+__export(ConfigManager_exports, {
+  ConfigManager: () => ConfigManager
+});
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import yaml from "js-yaml";
+var execFileAsync, GLOBAL_DIR, GLOBAL_CONFIG_PATH, DEFAULT_GLOBAL_CONFIG, ConfigManager;
+var init_ConfigManager = __esm({
+  "src/workspace/ConfigManager.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile);
+    GLOBAL_DIR = path.join(os.homedir(), ".nexus");
+    GLOBAL_CONFIG_PATH = path.join(GLOBAL_DIR, "config.yaml");
+    DEFAULT_GLOBAL_CONFIG = {
+      version: "1",
+      defaults: {
+        shell: process.env.SHELL || "/bin/bash",
+        scrollback_lines: 5e3,
+        grid_columns: 2,
+        history_retention_days: 30,
+        theme: "dark-ide"
+      },
+      agents: {
+        claudecode: {
+          bin: "claude",
+          continue_flag: "--continue",
+          resume_flag: "--resume",
+          yolo_flag: "--dangerously-skip-permissions",
+          statusline: true,
+          env: {}
+        },
+        opencode: {
+          bin: "opencode",
+          continue_flag: "--continue",
+          yolo_flag: "--yolo",
+          statusline: false,
+          env: {}
+        }
+      }
+    };
+    ConfigManager = class {
+      globalConfig = null;
+      workspaceConfig = null;
+      projectDir;
+      constructor(projectDir) {
+        this.projectDir = projectDir;
+      }
+      loadGlobalConfig() {
+        if (this.globalConfig) return this.globalConfig;
+        if (fs.existsSync(GLOBAL_CONFIG_PATH)) {
+          const content = fs.readFileSync(GLOBAL_CONFIG_PATH, "utf-8");
+          this.globalConfig = yaml.load(content);
+          let updated = false;
+          for (const [key, def] of Object.entries(DEFAULT_GLOBAL_CONFIG.agents)) {
+            if (!this.globalConfig.agents[key]) {
+              this.globalConfig.agents[key] = def;
+              updated = true;
+            } else {
+              const existing = this.globalConfig.agents[key];
+              for (const [field, value] of Object.entries(def)) {
+                if (!(field in existing)) {
+                  existing[field] = value;
+                  updated = true;
+                }
+              }
+            }
+          }
+          if (updated) {
+            this.saveGlobalConfig(this.globalConfig);
+          }
+        } else {
+          this.globalConfig = { ...DEFAULT_GLOBAL_CONFIG };
+          this.saveGlobalConfig(this.globalConfig);
+          this.detectAgentsAsync().then((detected) => {
+            if (Object.keys(detected).length > 0 && this.globalConfig) {
+              this.globalConfig.agents = { ...this.globalConfig.agents, ...detected };
+              this.saveGlobalConfig(this.globalConfig);
+            }
+          }).catch(() => {
+          });
+        }
+        return this.globalConfig;
+      }
+      saveGlobalConfig(config) {
+        fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+        fs.writeFileSync(GLOBAL_CONFIG_PATH, yaml.dump(config, { lineWidth: -1 }));
+      }
+      loadWorkspaceConfig() {
+        if (this.workspaceConfig) return this.workspaceConfig;
+        const configPath = path.join(this.projectDir, ".nexus", "config.yaml");
+        if (fs.existsSync(configPath)) {
+          const content = fs.readFileSync(configPath, "utf-8");
+          const parsed = yaml.load(content);
+          if (parsed) {
+            if (!Array.isArray(parsed.panes)) parsed.panes = [];
+            this.workspaceConfig = parsed;
+            return this.workspaceConfig;
+          }
+        }
+        return null;
+      }
+      saveWorkspaceConfig(config) {
+        const nexusDir = path.join(this.projectDir, ".nexus");
+        fs.mkdirSync(nexusDir, { recursive: true });
+        const configPath = path.join(nexusDir, "config.yaml");
+        fs.writeFileSync(configPath, yaml.dump(config, { lineWidth: -1 }));
+        this.workspaceConfig = config;
+      }
+      initWorkspace() {
+        const existing = this.loadWorkspaceConfig();
+        if (existing) return existing;
+        const dirName = path.basename(this.projectDir);
+        const isGit = fs.existsSync(path.join(this.projectDir, ".git"));
+        const config = {
+          version: "1",
+          name: dirName,
+          description: "",
+          repository: {
+            path: ".",
+            git: isGit
+          },
+          panes: []
+        };
+        this.saveWorkspaceConfig(config);
+        return config;
+      }
+      async detectAgentsAsync() {
+        const agents = {};
+        const agentBins = [
+          { key: "claudecode", bin: "claude", flag: "--continue", statusline: true },
+          { key: "codex", bin: "codex", flag: "", statusline: false },
+          { key: "opencode", bin: "opencode", flag: "--continue", statusline: false },
+          { key: "kimi-cli", bin: "kimi", flag: "--continue", statusline: false },
+          { key: "qwencode", bin: "qwen-code", flag: "--continue", statusline: false }
+        ];
+        const results = await Promise.allSettled(
+          agentBins.map(async (agent) => {
+            await execFileAsync("which", [agent.bin], { timeout: 3e3 });
+            return agent;
+          })
+        );
+        for (const result of results) {
+          if (result.status === "fulfilled") {
+            const agent = result.value;
+            agents[agent.key] = {
+              bin: agent.bin,
+              continue_flag: agent.flag,
+              statusline: agent.statusline,
+              env: {}
+            };
+          }
+        }
+        return agents;
+      }
+      getAgentDefinition(agentType) {
+        const global = this.loadGlobalConfig();
+        return global.agents[agentType];
+      }
+      getShell() {
+        const global = this.loadGlobalConfig();
+        const configured = global.defaults.shell;
+        const candidates = [
+          "/opt/homebrew/bin/zsh",
+          // macOS Apple Silicon Homebrew
+          "/usr/local/bin/zsh",
+          // macOS Intel Homebrew
+          "/usr/bin/zsh",
+          // Linux
+          "/bin/zsh",
+          // macOS default / Linux
+          configured,
+          process.env.SHELL,
+          "/bin/bash",
+          "/bin/sh"
+        ];
+        for (const sh of candidates) {
+          if (!sh) continue;
+          try {
+            fs.accessSync(sh, fs.constants.X_OK);
+            return sh;
+          } catch {
+          }
+        }
+        return "/bin/sh";
+      }
+      /**
+       * Check which agents are available (installed) on the system.
+       * Returns a record of agentType → { installed, bin, installHint }
+       */
+      async checkAgentAvailability() {
+        const global = this.loadGlobalConfig();
+        const knownAgents = [
+          { key: "claudecode", bin: "claude", installHint: "npm install -g @anthropic-ai/claude-code" },
+          { key: "codex", bin: "codex", installHint: "npm install -g @openai/codex" },
+          { key: "opencode", bin: "opencode", installHint: "go install github.com/opencode-ai/opencode@latest" },
+          { key: "kimi-cli", bin: "kimi", installHint: "pip install kimi-cli" },
+          { key: "qwencode", bin: "qwen-code", installHint: "pip install qwen-code" }
+        ];
+        const checks = await Promise.allSettled(
+          knownAgents.map(async (agent) => {
+            const def = global.agents[agent.key];
+            const bin = def?.bin || agent.bin;
+            try {
+              await execFileAsync("which", [bin], { timeout: 3e3 });
+              return { ...agent, bin, installed: true };
+            } catch {
+              return { ...agent, bin, installed: false };
+            }
+          })
+        );
+        const result = {};
+        for (const check of checks) {
+          if (check.status === "fulfilled") {
+            const { key, bin, installHint, installed } = check.value;
+            result[key] = { installed, bin, installHint };
+          }
+        }
+        return result;
+      }
+      updateGlobalConfig(config) {
+        this.globalConfig = config;
+        this.saveGlobalConfig(config);
+      }
+      getProjectDir() {
+        return this.projectDir;
+      }
+    };
+  }
+});
+
+// src/cli.ts
+import path10 from "path";
+import fs9 from "fs";
+
+// src/index.ts
+init_ConfigManager();
+import Fastify from "fastify";
+import fastifyWebsocket from "@fastify/websocket";
+import fastifyStatic from "@fastify/static";
+import path9 from "path";
+import fs8 from "fs";
+import yaml3 from "js-yaml";
+import { fileURLToPath } from "url";
+
+// src/pty/PtyManager.ts
+import * as pty from "node-pty";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// src/comm/StatuslineParser.ts
+var KNOWN_FIELDS = {
+  model: "string",
+  session_id: "string",
+  cost_usd: "number",
+  context_used_pct: "number",
+  cwd: "string",
+  tool_name: "string"
+  // Claude Code may add more fields — add them here as discovered
+};
+var MIN_KNOWN_FIELDS = 2;
+var StatuslineParser = class {
+  buffer = "";
+  /**
+   * Process raw PTY output data.
+   * Returns { cleanData, meta } where cleanData has statusline JSON stripped
+   * and meta contains parsed metadata (if any was found).
+   */
+  parse(data) {
+    let meta = null;
+    if (!data.includes("\n")) {
+      this.buffer += data;
+      return { cleanData: data, meta: null };
+    }
+    const combined = this.buffer + data;
+    this.buffer = "";
+    const lines = combined.split("\n");
+    const trailing = lines.pop() || "";
+    if (trailing) {
+      this.buffer = trailing;
+    }
+    const cleanLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.length < 10 || trimmed.charCodeAt(0) !== 123) {
+        cleanLines.push(line);
+        continue;
+      }
+      if (trimmed.charCodeAt(trimmed.length - 1) !== 125) {
+        cleanLines.push(line);
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        cleanLines.push(line);
+        continue;
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        cleanLines.push(line);
+        continue;
+      }
+      if (this.isStatuslineJson(parsed)) {
+        meta = this.extractMeta(parsed);
+        continue;
+      }
+      cleanLines.push(line);
+    }
+    let cleanData = cleanLines.join("\n");
+    if (cleanLines.length > 0) {
+      cleanData += "\n";
+    }
+    return { cleanData, meta };
+  }
+  /**
+   * Reset internal buffer state. Useful when restarting a pane.
+   */
+  reset() {
+    this.buffer = "";
+  }
+  isStatuslineJson(obj) {
+    let matchCount = 0;
+    for (const [field, expectedType] of Object.entries(KNOWN_FIELDS)) {
+      if (field in obj) {
+        if (typeof obj[field] === expectedType) {
+          matchCount++;
+        }
+      }
+    }
+    return matchCount >= MIN_KNOWN_FIELDS;
+  }
+  extractMeta(obj) {
+    const meta = {};
+    if (typeof obj.model === "string") {
+      meta.model = obj.model;
+    }
+    if (typeof obj.context_used_pct === "number") {
+      meta.contextUsedPct = obj.context_used_pct;
+    }
+    if (typeof obj.cost_usd === "number") {
+      meta.costUsd = obj.cost_usd;
+    }
+    if (typeof obj.session_id === "string") {
+      meta.sessionId = obj.session_id;
+    }
+    if (typeof obj.cwd === "string") {
+      meta.cwd = obj.cwd;
+    }
+    return meta;
+  }
+};
+
+// src/comm/ShellReadyDetector.ts
+var FALLBACK_TIMEOUT_MS = 8e3;
+var ShellReadyDetector = class {
+  constructor(paneId, options = {}) {
+    this.paneId = paneId;
+    this.options = options;
+    this.sentinel = `__NEXUS_RDY_${paneId}_${Date.now().toString(36)}__`;
+    this.startTime = Date.now();
+    this.promise = new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+  sentinel;
+  resolve;
+  promise;
+  startTime;
+  timer = null;
+  disposed = false;
+  // Exposed for testing — accumulated raw output chunks
+  chunks = [];
+  /**
+   * Inject the sentinel into the shell and start watching.
+   * Call this immediately after pty.spawn().
+   *
+   * Returns a promise that resolves when the shell is ready.
+   * The caller should await this before sending any agent command.
+   */
+  start(term) {
+    const timeoutMs = this.options.timeoutMs ?? FALLBACK_TIMEOUT_MS;
+    term.write(`echo ${this.sentinel}\r`);
+    this.timer = setTimeout(() => {
+      if (!this.disposed) {
+        this.disposed = true;
+        this.resolve({
+          detected: false,
+          elapsedMs: Date.now() - this.startTime
+        });
+      }
+    }, timeoutMs);
+    return this.promise;
+  }
+  /**
+   * Feed PTY output data into the detector.
+   * Call this from the PTY onData handler.
+   *
+   * Returns the data with the sentinel line stripped if `stripSentinel` is true
+   * and the sentinel was found in this chunk. Otherwise returns the data as-is.
+   */
+  feed(data) {
+    if (this.disposed) return data;
+    this.chunks.push(data);
+    const recent = this.chunks.length <= 3 ? this.chunks.join("") : this.chunks.slice(-3).join("");
+    if (recent.includes(this.sentinel)) {
+      this.disposed = true;
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+      this.resolve({
+        detected: true,
+        elapsedMs: Date.now() - this.startTime
+      });
+      this.chunks = [];
+      if (this.options.stripSentinel) {
+        return this.stripSentinelFromData(data);
+      }
+    }
+    return data;
+  }
+  /**
+   * Whether the detector has finished (either by detection or timeout).
+   */
+  get isDone() {
+    return this.disposed;
+  }
+  /**
+   * Clean up without resolving (e.g., if the PTY is killed before ready).
+   */
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = true;
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+      this.resolve({
+        detected: false,
+        elapsedMs: Date.now() - this.startTime
+      });
+    }
+    this.chunks = [];
+  }
+  stripSentinelFromData(data) {
+    const lines = data.split("\n");
+    const filtered = lines.filter((line) => !line.includes(this.sentinel));
+    return filtered.join("\n");
+  }
+};
+
+// src/comm/AgentReadyDetector.ts
+var DEFAULT_QUIESCENCE_MS = 3e3;
+var DEFAULT_HARD_TIMEOUT_MS = 15e3;
+var PROMPT_PATTERNS = [
+  /❯\s*$/,
+  // Claude Code prompt
+  />\s*$/,
+  // Generic prompt
+  /\$\s*$/,
+  // Shell-style prompt (some agents)
+  /waiting for input/i
+];
+var AgentReadyDetector = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.startTime = Date.now();
+    this.quiescenceMs = options.quiescenceMs ?? DEFAULT_QUIESCENCE_MS;
+    this.promptPatterns = [
+      ...PROMPT_PATTERNS,
+      ...options.extraPromptPatterns || []
+    ];
+    this.promise = new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+  resolve;
+  promise;
+  startTime;
+  disposed = false;
+  quiescenceTimer = null;
+  hardTimer = null;
+  quiescenceMs;
+  promptPatterns;
+  /**
+   * Start the detection timers. Returns a promise that resolves when the
+   * agent is deemed ready.
+   */
+  start() {
+    const hardTimeoutMs = this.options.hardTimeoutMs ?? DEFAULT_HARD_TIMEOUT_MS;
+    this.hardTimer = setTimeout(() => {
+      this.finish("timeout");
+    }, hardTimeoutMs);
+    this.resetQuiescence();
+    return this.promise;
+  }
+  /**
+   * Feed terminal output from the agent. Resets quiescence timer and
+   * checks for prompt patterns.
+   */
+  feed(data) {
+    if (this.disposed) return;
+    this.resetQuiescence();
+    const clean = stripAnsi(data);
+    const tail = clean.slice(-200);
+    for (const pattern of this.promptPatterns) {
+      if (pattern.test(tail)) {
+        this.finish("prompt");
+        return;
+      }
+    }
+  }
+  /**
+   * Called when a statusline meta event is received. If it contains a
+   * session_id, the agent is definitely ready.
+   */
+  onMeta(meta) {
+    if (this.disposed) return;
+    if (meta.sessionId) {
+      this.finish("statusline");
+    }
+  }
+  get isDone() {
+    return this.disposed;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = true;
+      this.clearTimers();
+      this.resolve({
+        reason: "timeout",
+        elapsedMs: Date.now() - this.startTime
+      });
+    }
+  }
+  finish(reason) {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.clearTimers();
+    this.resolve({
+      reason,
+      elapsedMs: Date.now() - this.startTime
+    });
+  }
+  resetQuiescence() {
+    if (this.quiescenceTimer) {
+      clearTimeout(this.quiescenceTimer);
+    }
+    this.quiescenceTimer = setTimeout(() => {
+      this.finish("quiescence");
+    }, this.quiescenceMs);
+  }
+  clearTimers() {
+    if (this.quiescenceTimer) {
+      clearTimeout(this.quiescenceTimer);
+      this.quiescenceTimer = null;
+    }
+    if (this.hardTimer) {
+      clearTimeout(this.hardTimer);
+      this.hardTimer = null;
+    }
+  }
+};
+function stripAnsi(str) {
+  return str.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "");
+}
+
+// src/comm/OutputStateAnalyzer.ts
+var DEFAULT_IDLE_THRESHOLD_MS = 5e3;
+var OutputStateAnalyzer = class {
+  currentStatus = "running";
+  lastOutputTime = 0;
+  lastContextPct = null;
+  idleTimer = null;
+  extendedIdleTimer = null;
+  idleThresholdMs;
+  onStatusChange;
+  constructor(options = {}) {
+    this.idleThresholdMs = options.idleThresholdMs ?? DEFAULT_IDLE_THRESHOLD_MS;
+    this.onStatusChange = options.onStatusChange;
+    this.lastOutputTime = Date.now();
+  }
+  /**
+   * Call on every PTY output chunk. Must be fast — hot path.
+   */
+  onOutput() {
+    this.lastOutputTime = Date.now();
+    if (this.currentStatus === "waiting" || this.currentStatus === "idle") {
+      this.setStatus("running");
+    }
+    this.resetIdleTimers();
+  }
+  /**
+   * Call when a statusline meta event is received.
+   * Context usage changes confirm the agent is actively working.
+   */
+  onMeta(meta) {
+    if (meta.contextUsedPct !== void 0) {
+      if (this.lastContextPct !== null && meta.contextUsedPct > this.lastContextPct) {
+        if (this.currentStatus !== "running") {
+          this.setStatus("running");
+        }
+        this.resetIdleTimers();
+      }
+      this.lastContextPct = meta.contextUsedPct;
+    }
+  }
+  /**
+   * Call when the PTY process exits. Overrides any inferred state.
+   */
+  onExit(exitCode) {
+    this.clearTimers();
+    this.setStatus(exitCode === 0 ? "stopped" : "error");
+  }
+  /**
+   * Get the current inferred status.
+   */
+  getStatus() {
+    return this.currentStatus;
+  }
+  /**
+   * Milliseconds since last output.
+   */
+  getSilenceMs() {
+    return Date.now() - this.lastOutputTime;
+  }
+  /**
+   * Clean up timers.
+   */
+  dispose() {
+    this.clearTimers();
+  }
+  setStatus(status) {
+    if (status === this.currentStatus) return;
+    this.currentStatus = status;
+    this.onStatusChange?.(status);
+  }
+  resetIdleTimers() {
+    this.clearTimers();
+    this.idleTimer = setTimeout(() => {
+      if (this.currentStatus === "running") {
+        this.setStatus("waiting");
+      }
+      this.extendedIdleTimer = setTimeout(() => {
+        if (this.currentStatus === "waiting") {
+          this.setStatus("idle");
+        }
+      }, this.idleThresholdMs * 2);
+    }, this.idleThresholdMs);
+  }
+  clearTimers() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.extendedIdleTimer) {
+      clearTimeout(this.extendedIdleTimer);
+      this.extendedIdleTimer = null;
+    }
+  }
+};
+
+// src/pty/ActivityParser.ts
+function stripAnsi2(str) {
+  return str.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b[()][AB012]/g, "").replace(/\x1b[>=<]/g, "").replace(/\x0f|\x0e/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "");
+}
+var ActivityParser = class {
+  buffer = "";
+  lastFile = "";
+  lastTime = 0;
+  DEDUP_MS = 2e3;
+  // Ignore same file within 2s
+  parse(data) {
+    if (!data.includes("\n")) {
+      this.buffer += data;
+      return null;
+    }
+    const lines = (this.buffer + data).split("\n");
+    this.buffer = "";
+    const trailing = lines.pop() || "";
+    if (trailing) {
+      this.buffer = trailing;
+    }
+    for (const line of lines) {
+      const activity = this.parseLine(line);
+      if (activity) {
+        if (activity.file === this.lastFile && activity.timestamp - this.lastTime < this.DEDUP_MS) {
+          continue;
+        }
+        this.lastFile = activity.file;
+        this.lastTime = activity.timestamp;
+        return activity;
+      }
+    }
+    return null;
+  }
+  parseLine(line) {
+    const clean = stripAnsi2(line).trim();
+    if (!clean || clean.length < 5) return null;
+    const toolResultMatch = clean.match(
+      /^[⎿│├└┌┐┘┤┬┴┼╭╮╰╯─━]?\s*(Read|Edit|Write|MultiEdit|Create|Delete|Glob|Grep|Bash)\s+(.+)/i
+    );
+    if (toolResultMatch) {
+      return this.buildActivity(toolResultMatch[1], toolResultMatch[2]);
+    }
+    const toolStartMatch = clean.match(
+      /^(Read|Edit|Write|MultiEdit|Create|Delete)\s+([^\s(][^\s]*\.\w{1,10})\b/
+    );
+    if (toolStartMatch) {
+      return this.buildActivity(toolStartMatch[1], toolStartMatch[2]);
+    }
+    const parenMatch = clean.match(
+      /\b(Read|Edit|Write|MultiEdit|Create|Delete)\((?:file_path\s*[:=]\s*)?["']?([^"')]+\.\w{1,10})["']?\)/i
+    );
+    if (parenMatch) {
+      return this.buildActivity(parenMatch[1], parenMatch[2]);
+    }
+    const jsonFieldMatch = clean.match(
+      /["']?file_path["']?\s*[:=]\s*["']([^"']+\.\w{1,10})["']/i
+    );
+    if (jsonFieldMatch) {
+      const action = this.inferActionFromContext(clean);
+      return this.buildActivity(action, jsonFieldMatch[1]);
+    }
+    const colonMatch = clean.match(
+      /(?:─+\s*)?(Read|Edit|Write|MultiEdit|Create|Delete)\s*:\s*(.+?)(?:\s*─+)?$/i
+    );
+    if (colonMatch) {
+      return this.buildActivity(colonMatch[1], colonMatch[2]);
+    }
+    const spinnerMatch = clean.match(
+      /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⠿✓✗✔✘●◉▶▸►◆◇■□▪▫★☆○◎]\s*(Read|Edit|Write|MultiEdit|Create|Delete)\s+(.+)/i
+    );
+    if (spinnerMatch) {
+      return this.buildActivity(spinnerMatch[1], spinnerMatch[2]);
+    }
+    const indentedPathMatch = clean.match(
+      /^([a-zA-Z0-9_][a-zA-Z0-9_./\-]*\.\w{1,10})$/
+    );
+    if (indentedPathMatch && line.startsWith(" ")) {
+      return this.buildActivity("Read", indentedPathMatch[1]);
+    }
+    return null;
+  }
+  buildActivity(toolName, rawPath) {
+    const file = this.cleanPath(rawPath);
+    if (!file || !this.isValidPath(file)) return null;
+    const action = this.toolToAction(toolName);
+    return { file, action, timestamp: Date.now() };
+  }
+  toolToAction(tool) {
+    switch (tool.toLowerCase()) {
+      case "read":
+      case "glob":
+      case "grep":
+        return "read";
+      case "edit":
+      case "multiedit":
+        return "edit";
+      case "write":
+        return "write";
+      case "create":
+        return "create";
+      case "delete":
+        return "delete";
+      case "bash":
+        return "bash";
+      default:
+        return "read";
+    }
+  }
+  inferActionFromContext(line) {
+    const lower = line.toLowerCase();
+    if (lower.includes("edit") || lower.includes("old_string") || lower.includes("new_string")) return "Edit";
+    if (lower.includes("write") || lower.includes("content")) return "Write";
+    if (lower.includes("delete") || lower.includes("remove")) return "Delete";
+    return "Read";
+  }
+  cleanPath(raw) {
+    return raw.trim().replace(/^['"`]+|['"`]+$/g, "").replace(/^\.\//, "").replace(/\s+.*$/, "").replace(/[,;:)]+$/, "").replace(/^\(/, "");
+  }
+  isValidPath(file) {
+    if (!file || file.length < 3) return false;
+    if (!/\.\w{1,10}$/.test(file)) return false;
+    if (file.startsWith("/") || file.includes("://")) return false;
+    if (/[<>|&$`\\{}[\]]/.test(file)) return false;
+    const parts = file.split("/");
+    if (parts.length > 15) return false;
+    for (const part of parts) {
+      if (part.length > 100 || part.length === 0) return false;
+    }
+    return true;
+  }
+};
+
+// src/pty/PtyManager.ts
+var MAX_SCROLLBACK_BYTES = 512 * 1024;
+var PtyManager = class {
+  entries = /* @__PURE__ */ new Map();
+  configManager;
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+  spawn(paneId, config, cols = 80, rows = 24) {
+    if (this.entries.has(paneId)) {
+      this.kill(paneId);
+    }
+    const shell = this.configManager.getShell();
+    console.log(`[PTY] Using shell: ${shell} for pane ${paneId}`);
+    const projectDir = this.configManager.getProjectDir();
+    const basePath = config.isolation === "worktree" && config.worktreePath ? config.worktreePath : projectDir;
+    let cwd = config.workdir ? path2.resolve(basePath, config.workdir) : basePath;
+    if (!fs2.existsSync(cwd)) {
+      console.warn(`[PTY] cwd does not exist: ${cwd}, falling back to ${projectDir}`);
+      cwd = fs2.existsSync(projectDir) ? projectDir : os2.homedir();
+    }
+    let resolvedShell = shell;
+    if (!fs2.existsSync(resolvedShell)) {
+      const fallbacks = ["/bin/zsh", "/bin/bash", "/bin/sh"];
+      const found = fallbacks.find((s) => fs2.existsSync(s));
+      console.error(`[PTY] Shell binary not found: ${resolvedShell}, falling back to ${found || "/bin/sh"}`);
+      resolvedShell = found || "/bin/sh";
+    }
+    const agentDef = this.configManager.getAgentDefinition(config.agent);
+    const isAgent = agentDef && config.agent !== "__shell__";
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== void 0 && !key.startsWith("CLAUDE") && key !== "CLAUDECODE") {
+        env[key] = value;
+      }
+    }
+    if (agentDef?.env) {
+      for (const [key, value] of Object.entries(agentDef.env)) {
+        const resolved = value.replace(/\$\{(\w+)\}/g, (_, varName) => {
+          return process.env[varName] || "";
+        });
+        if (resolved) env[key] = resolved;
+      }
+    }
+    if (!env.PATH) {
+      env.PATH = "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+      if (process.platform === "darwin") {
+        env.PATH = "/opt/homebrew/bin:/opt/homebrew/sbin:" + env.PATH;
+      }
+    }
+    console.log(`[PTY] Spawning pane ${paneId}: shell=${resolvedShell}, cwd=${cwd}`);
+    const term = pty.spawn(resolvedShell, [], {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd,
+      env
+    });
+    const shellDetector = isAgent ? new ShellReadyDetector(paneId, { stripSentinel: true }) : null;
+    const stateAnalyzer = new OutputStateAnalyzer({
+      idleThresholdMs: 5e3,
+      onStatusChange: (status) => {
+        const e = this.entries.get(paneId);
+        if (e) {
+          e.status = status;
+          for (const cb of e.onStatusCallbacks) {
+            cb(status);
+          }
+        }
+      }
+    });
+    const entry = {
+      pty: term,
+      config,
+      status: "running",
+      meta: {},
+      parser: new StatuslineParser(),
+      activityParser: new ActivityParser(),
+      stateAnalyzer,
+      shellDetector,
+      agentDetector: null,
+      // Created after shell is ready
+      scrollback: [],
+      scrollbackBytes: 0,
+      onDataCallbacks: [],
+      onStatusCallbacks: [],
+      onMetaCallbacks: [],
+      onActivityCallbacks: []
+    };
+    this.entries.set(paneId, entry);
+    term.onData((data) => {
+      let processedData = data;
+      if (entry.shellDetector && !entry.shellDetector.isDone) {
+        processedData = entry.shellDetector.feed(data);
+      }
+      if (entry.agentDetector && !entry.agentDetector.isDone) {
+        entry.agentDetector.feed(processedData);
+      }
+      const { cleanData, meta } = entry.parser.parse(processedData);
+      if (cleanData) {
+        entry.stateAnalyzer.onOutput();
+        entry.scrollback.push(cleanData);
+        entry.scrollbackBytes += cleanData.length;
+        while (entry.scrollbackBytes > MAX_SCROLLBACK_BYTES && entry.scrollback.length > 1) {
+          const removed = entry.scrollback.shift();
+          entry.scrollbackBytes -= removed.length;
+        }
+        for (const cb of entry.onDataCallbacks) {
+          cb(cleanData);
+        }
+      }
+      if (meta) {
+        entry.meta = { ...entry.meta, ...meta };
+        entry.stateAnalyzer.onMeta(meta);
+        if (entry.agentDetector && !entry.agentDetector.isDone) {
+          entry.agentDetector.onMeta(meta);
+        }
+        for (const cb of entry.onMetaCallbacks) {
+          cb(entry.meta);
+        }
+      }
+      if (config.agent !== "__shell__") {
+        const activity = entry.activityParser.parse(data);
+        if (activity) {
+          for (const cb of entry.onActivityCallbacks) {
+            cb(activity);
+          }
+        }
+      }
+    });
+    term.onExit(({ exitCode }) => {
+      const e = this.entries.get(paneId);
+      if (e) {
+        e.stateAnalyzer.onExit(exitCode);
+        e.shellDetector?.dispose();
+        e.agentDetector?.dispose();
+      }
+    });
+    if (isAgent && shellDetector) {
+      this.startAgentSequence(paneId, config, agentDef, shellDetector);
+    }
+    return term.pid;
+  }
+  /**
+   * Orchestrates the shell → agent → task startup sequence using
+   * event-driven detectors instead of hardcoded setTimeout delays.
+   */
+  async startAgentSequence(paneId, config, agentDef, shellDetector) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    const shellResult = await shellDetector.start(entry.pty);
+    if (!this.entries.has(paneId)) return;
+    console.log(`[PTY] Shell ready for ${paneId}: detected=${shellResult.detected} (${shellResult.elapsedMs}ms)`);
+    this.sendAgentCommand(paneId, config, agentDef);
+    if (config.task && config.restore !== "manual") {
+      const agentDetector = new AgentReadyDetector({
+        quiescenceMs: 3e3,
+        hardTimeoutMs: 15e3
+      });
+      entry.agentDetector = agentDetector;
+      const agentResult = await agentDetector.start();
+      if (!this.entries.has(paneId)) return;
+      console.log(`[PTY] Agent ready for ${paneId}: reason=${agentResult.reason} (${agentResult.elapsedMs}ms)`);
+      entry.pty.write(config.task + "\r");
+    }
+  }
+  sendAgentCommand(paneId, config, agentDef) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    let cmd = agentDef.bin;
+    if (config.restore === "resume" && config.sessionId && agentDef.resume_flag) {
+      cmd += ` ${agentDef.resume_flag} ${config.sessionId}`;
+    } else if (config.restore === "continue" && agentDef.continue_flag) {
+      cmd += ` ${agentDef.continue_flag}`;
+    }
+    if (config.yolo && agentDef.yolo_flag) {
+      cmd += ` ${agentDef.yolo_flag}`;
+    }
+    entry.pty.write(cmd + "\r");
+  }
+  write(paneId, data) {
+    const entry = this.entries.get(paneId);
+    if (entry) {
+      entry.pty.write(data);
+    }
+  }
+  resize(paneId, cols, rows) {
+    const entry = this.entries.get(paneId);
+    if (entry) {
+      try {
+        entry.pty.resize(cols, rows);
+      } catch {
+      }
+    }
+  }
+  kill(paneId) {
+    const entry = this.entries.get(paneId);
+    if (entry) {
+      entry.stateAnalyzer.dispose();
+      entry.shellDetector?.dispose();
+      entry.agentDetector?.dispose();
+      entry.parser.reset();
+      try {
+        entry.pty.kill();
+      } catch {
+      }
+      this.entries.delete(paneId);
+    }
+  }
+  killAll() {
+    for (const [paneId] of this.entries) {
+      this.kill(paneId);
+    }
+  }
+  getStatus(paneId) {
+    return this.entries.get(paneId)?.status || "stopped";
+  }
+  getMeta(paneId) {
+    return this.entries.get(paneId)?.meta || {};
+  }
+  getPid(paneId) {
+    return this.entries.get(paneId)?.pty.pid;
+  }
+  onData(paneId, callback) {
+    const entry = this.entries.get(paneId);
+    if (entry) {
+      entry.onDataCallbacks.push(callback);
+    }
+  }
+  onStatus(paneId, callback) {
+    const entry = this.entries.get(paneId);
+    if (entry) {
+      entry.onStatusCallbacks.push(callback);
+    }
+  }
+  onMeta(paneId, callback) {
+    const entry = this.entries.get(paneId);
+    if (entry) {
+      entry.onMetaCallbacks.push(callback);
+    }
+  }
+  onActivity(paneId, callback) {
+    const entry = this.entries.get(paneId);
+    if (entry) {
+      entry.onActivityCallbacks.push(callback);
+    }
+  }
+  getScrollback(paneId) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return "";
+    return entry.scrollback.join("");
+  }
+  has(paneId) {
+    return this.entries.has(paneId);
+  }
+};
+
+// src/git/WorktreeManager.ts
+import path3 from "path";
+import fs3 from "fs";
+import { simpleGit } from "simple-git";
+var WorktreeManager = class {
+  projectDir;
+  git;
+  worktrees = /* @__PURE__ */ new Map();
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.git = simpleGit(projectDir);
+  }
+  /**
+   * Create a git worktree + branch for a pane.
+   * Returns the worktree disk path and branch name.
+   */
+  async create(paneId, paneName) {
+    const baseBranch = await this.getCurrentBranch();
+    const slug = this.slugify(paneName);
+    const branch = `nexus/${paneId}-${slug}`;
+    const worktreePath = path3.join(this.projectDir, ".nexus", "worktrees", paneId);
+    if (fs3.existsSync(worktreePath)) {
+      await this.forceRemoveWorktree(worktreePath);
+    }
+    try {
+      await this.git.raw(["branch", "-D", branch]);
+    } catch {
+    }
+    fs3.mkdirSync(path3.dirname(worktreePath), { recursive: true });
+    await this.git.raw(["worktree", "add", "-b", branch, worktreePath, baseBranch]);
+    const entry = { path: worktreePath, branch, baseBranch };
+    this.worktrees.set(paneId, entry);
+    return { worktreePath, branch };
+  }
+  /**
+   * Remove a worktree. Branch is kept for later merge/PR.
+   */
+  async remove(paneId) {
+    const entry = this.worktrees.get(paneId);
+    if (!entry) return;
+    await this.forceRemoveWorktree(entry.path);
+    this.worktrees.delete(paneId);
+  }
+  /**
+   * Remove worktree and also delete the branch.
+   */
+  async removeWithBranch(paneId) {
+    const entry = this.worktrees.get(paneId);
+    if (!entry) return;
+    await this.forceRemoveWorktree(entry.path);
+    try {
+      await this.git.raw(["branch", "-D", entry.branch]);
+    } catch {
+    }
+    this.worktrees.delete(paneId);
+  }
+  /**
+   * Get diffs for a worktree pane relative to its base branch.
+   */
+  async getDiffs(paneId) {
+    const entry = this.worktrees.get(paneId);
+    if (!entry) return [];
+    const wtGit = simpleGit(entry.path);
+    const diffs = [];
+    try {
+      const status = await wtGit.status();
+      const committedDiff = await wtGit.diff([`${entry.baseBranch}...HEAD`]).catch(() => "");
+      const uncommittedDiff = await wtGit.diff();
+      const stagedDiff = await wtGit.diff(["--cached"]);
+      const combinedDiff = [committedDiff, uncommittedDiff, stagedDiff].filter(Boolean).join("\n");
+      const allFiles = /* @__PURE__ */ new Set();
+      const fileStatuses = /* @__PURE__ */ new Map();
+      if (committedDiff) {
+        const parsed = this.parseFileDiffs(committedDiff);
+        for (const [file] of parsed) {
+          allFiles.add(file);
+          fileStatuses.set(file, "modified");
+        }
+      }
+      for (const file of status.created) {
+        allFiles.add(file);
+        fileStatuses.set(file, "added");
+      }
+      for (const file of status.modified) {
+        allFiles.add(file);
+        if (!fileStatuses.has(file)) fileStatuses.set(file, "modified");
+      }
+      for (const file of status.deleted) {
+        allFiles.add(file);
+        fileStatuses.set(file, "deleted");
+      }
+      for (const file of status.renamed) {
+        allFiles.add(file.to);
+        fileStatuses.set(file.to, "renamed");
+      }
+      for (const file of status.staged) {
+        if (!allFiles.has(file)) {
+          allFiles.add(file);
+          fileStatuses.set(file, "modified");
+        }
+      }
+      const hunkMap = combinedDiff ? this.parseFileDiffs(combinedDiff) : /* @__PURE__ */ new Map();
+      for (const file of allFiles) {
+        diffs.push({
+          file,
+          status: fileStatuses.get(file) || "modified",
+          hunks: hunkMap.get(file) || ""
+        });
+      }
+    } catch (err) {
+      console.warn(`[WorktreeManager] getDiffs failed for ${paneId}:`, err.message);
+    }
+    return diffs;
+  }
+  getWorktreePath(paneId) {
+    return this.worktrees.get(paneId)?.path;
+  }
+  getBranch(paneId) {
+    return this.worktrees.get(paneId)?.branch;
+  }
+  getBaseBranch(paneId) {
+    return this.worktrees.get(paneId)?.baseBranch;
+  }
+  has(paneId) {
+    return this.worktrees.has(paneId);
+  }
+  /**
+   * Clean up all worktrees on shutdown.
+   */
+  async removeAll() {
+    for (const [paneId] of this.worktrees) {
+      await this.remove(paneId);
+    }
+  }
+  async getCurrentBranch() {
+    try {
+      const branch = await this.git.revparse(["--abbrev-ref", "HEAD"]);
+      return branch.trim() || "HEAD";
+    } catch {
+      return "HEAD";
+    }
+  }
+  slugify(name) {
+    return name.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
+  }
+  async forceRemoveWorktree(wtPath) {
+    try {
+      await this.git.raw(["worktree", "remove", "--force", wtPath]);
+    } catch {
+      try {
+        fs3.rmSync(wtPath, { recursive: true, force: true });
+        await this.git.raw(["worktree", "prune"]);
+      } catch {
+      }
+    }
+  }
+  parseFileDiffs(diffText) {
+    const result = /* @__PURE__ */ new Map();
+    const fileSections = diffText.split(/^diff --git /m).filter(Boolean);
+    for (const section of fileSections) {
+      const headerMatch = section.match(/^a\/(.+?) b\/(.+)/);
+      if (!headerMatch) continue;
+      const filename = headerMatch[2];
+      result.set(filename, `diff --git ${section}`);
+    }
+    return result;
+  }
+};
+
+// src/git/GitService.ts
+import path4 from "path";
+import { simpleGit as simpleGit2 } from "simple-git";
+import { watch } from "chokidar";
+var GitService = class {
+  git;
+  projectDir;
+  gitWatcher = null;
+  workWatcher = null;
+  debounceTimer = null;
+  workDebounceTimer = null;
+  listeners = /* @__PURE__ */ new Set();
+  currentResult = { unstaged: [], staged: [] };
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.git = simpleGit2(projectDir);
+  }
+  async start() {
+    const isRepo = await this.git.checkIsRepo();
+    if (!isRepo) return;
+    await this.refresh();
+    const scheduleRefresh = () => {
+      if (this.debounceTimer) clearTimeout(this.debounceTimer);
+      this.debounceTimer = setTimeout(() => {
+        this.refresh();
+      }, 1e3);
+    };
+    const gitDir = path4.join(this.projectDir, ".git");
+    this.gitWatcher = watch([
+      path4.join(gitDir, "index"),
+      path4.join(gitDir, "HEAD"),
+      path4.join(gitDir, "refs")
+    ], {
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.gitWatcher.on("all", scheduleRefresh);
+    const scheduleWorkRefresh = () => {
+      if (this.workDebounceTimer) clearTimeout(this.workDebounceTimer);
+      this.workDebounceTimer = setTimeout(() => {
+        this.refresh();
+      }, 3e3);
+    };
+    this.workWatcher = watch(this.projectDir, {
+      ignored: (filePath) => {
+        const basename = path4.basename(filePath);
+        return basename === ".git" || basename === "node_modules" || basename === ".nexus" || basename === "dist";
+      },
+      persistent: true,
+      ignoreInitial: true,
+      depth: 5
+    });
+    this.workWatcher.on("all", scheduleWorkRefresh);
+  }
+  async refresh() {
+    try {
+      const result = await this.getDiffs();
+      this.currentResult = result;
+      this.notifyListeners();
+    } catch {
+    }
+  }
+  getCurrentDiffs() {
+    return this.currentResult;
+  }
+  onDiffChange(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  // ─── Stage / Unstage ─────────────────────────────────────
+  async acceptFile(file) {
+    await this.git.add(file);
+    await this.refresh();
+  }
+  async acceptAll() {
+    await this.git.add("-A");
+    await this.refresh();
+  }
+  async unstageFile(file) {
+    await this.git.reset(["HEAD", "--", file]);
+    await this.refresh();
+  }
+  async unstageAll() {
+    await this.git.reset(["HEAD"]);
+    await this.refresh();
+  }
+  // ─── Discard ──────────────────────────────────────────────
+  async discardFile(file) {
+    const status = await this.git.status();
+    const isUntracked = status.not_added.includes(file) || status.created.includes(file);
+    if (isUntracked) {
+      const fullPath = path4.join(this.projectDir, file);
+      const fs10 = await import("fs");
+      if (fs10.existsSync(fullPath)) {
+        fs10.unlinkSync(fullPath);
+      }
+    } else {
+      await this.git.checkout(["--", file]);
+      try {
+        await this.git.reset(["HEAD", "--", file]);
+      } catch {
+      }
+    }
+    await this.refresh();
+  }
+  async discardAll() {
+    await this.git.checkout(["--", "."]);
+    await this.git.clean("f", ["-d"]);
+    await this.refresh();
+  }
+  // ─── Commit / Push ────────────────────────────────────────
+  async commit(message) {
+    const result = await this.git.commit(message);
+    await this.refresh();
+    const summary = result.summary;
+    return `${summary.changes} file${summary.changes !== 1 ? "s" : ""}, +${summary.insertions} -${summary.deletions}`;
+  }
+  async push() {
+    await this.git.push();
+    await this.refresh();
+    return "Pushed successfully";
+  }
+  async getBranchInfo() {
+    const status = await this.git.status();
+    return {
+      branch: status.current || "HEAD",
+      remote: status.tracking || void 0,
+      ahead: status.ahead,
+      behind: status.behind
+    };
+  }
+  // ─── Cleanup ──────────────────────────────────────────────
+  close() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    if (this.workDebounceTimer) clearTimeout(this.workDebounceTimer);
+    this.gitWatcher?.close();
+    this.gitWatcher = null;
+    this.workWatcher?.close();
+    this.workWatcher = null;
+  }
+  // ─── Internal ─────────────────────────────────────────────
+  async getDiffs() {
+    const status = await this.git.status();
+    const unstaged = [];
+    const staged = [];
+    const [unstagedDiffText, stagedDiffText] = await Promise.all([
+      this.git.diff(),
+      this.git.diff(["--cached"])
+    ]);
+    const unstagedHunks = this.parseFileDiffs(unstagedDiffText);
+    const stagedHunks = this.parseFileDiffs(stagedDiffText);
+    const stagedFiles = new Set(status.staged);
+    for (const file of status.not_added) {
+      unstaged.push({ file, status: "added", hunks: "" });
+    }
+    for (const file of status.created) {
+      if (!stagedFiles.has(file)) {
+        unstaged.push({ file, status: "added", hunks: "" });
+      }
+    }
+    for (const file of status.deleted) {
+      if (!stagedFiles.has(file)) {
+        unstaged.push({ file, status: "deleted", hunks: "" });
+      }
+    }
+    for (const file of status.modified) {
+      unstaged.push({ file, status: "modified", hunks: unstagedHunks.get(file) || "" });
+    }
+    for (const file of status.renamed) {
+      if (!stagedFiles.has(file.to)) {
+        unstaged.push({ file: file.to, status: "renamed", hunks: "" });
+      }
+    }
+    for (const diff of unstaged) {
+      if (!diff.hunks && unstagedHunks.has(diff.file)) {
+        diff.hunks = unstagedHunks.get(diff.file);
+      }
+    }
+    for (const diff of unstaged) {
+      if (diff.status === "added" && !diff.hunks) {
+        try {
+          const content = await this.git.show([`:${diff.file}`]).catch(() => null);
+          if (content) {
+            diff.hunks = `--- /dev/null
++++ b/${diff.file}
+@@ -0,0 +1 @@
++${content}`;
+          }
+        } catch {
+        }
+      }
+    }
+    for (const fileResult of status.files) {
+      const indexStatus = fileResult.index;
+      if (!indexStatus || indexStatus === "?" || indexStatus === " ") continue;
+      const file = fileResult.path;
+      let diffStatus = "modified";
+      if (indexStatus === "A") diffStatus = "added";
+      else if (indexStatus === "D") diffStatus = "deleted";
+      else if (indexStatus === "R") diffStatus = "renamed";
+      staged.push({
+        file,
+        status: diffStatus,
+        hunks: stagedHunks.get(file) || ""
+      });
+    }
+    return { unstaged, staged };
+  }
+  parseFileDiffs(diffText) {
+    const result = /* @__PURE__ */ new Map();
+    if (!diffText) return result;
+    const fileSections = diffText.split(/^diff --git /m).filter(Boolean);
+    for (const section of fileSections) {
+      const headerMatch = section.match(/^a\/(.+?) b\/(.+)/);
+      if (!headerMatch) continue;
+      const filename = headerMatch[2];
+      result.set(filename, `diff --git ${section}`);
+    }
+    return result;
+  }
+  notifyListeners() {
+    for (const listener of this.listeners) {
+      listener(this.currentResult);
+    }
+  }
+};
+
+// src/workspace/WorkspaceManager.ts
+var paneCounter = 0;
+function nextPaneId() {
+  return `pane-${++paneCounter}`;
+}
+var WorkspaceManager = class {
+  panes = /* @__PURE__ */ new Map();
+  ptyManager;
+  configManager;
+  worktreeManager;
+  perPaneGitServices = /* @__PURE__ */ new Map();
+  wsName = "";
+  wsDescription = "";
+  // Multi-client event listener sets
+  listeners = {
+    onPaneAdded: /* @__PURE__ */ new Set(),
+    onPaneRemoved: /* @__PURE__ */ new Set(),
+    onPaneStatus: /* @__PURE__ */ new Set(),
+    onPaneMeta: /* @__PURE__ */ new Set(),
+    onTerminalData: /* @__PURE__ */ new Set(),
+    onPaneActivity: /* @__PURE__ */ new Set(),
+    onFileActivity: /* @__PURE__ */ new Set(),
+    onFileTree: /* @__PURE__ */ new Set(),
+    onGitDiff: /* @__PURE__ */ new Set(),
+    onPaneDiff: /* @__PURE__ */ new Set()
+  };
+  constructor(configManager) {
+    this.configManager = configManager;
+    this.ptyManager = new PtyManager(configManager);
+    this.worktreeManager = new WorktreeManager(configManager.getProjectDir());
+  }
+  init() {
+    const wsConfig = this.configManager.initWorkspace();
+    this.wsName = wsConfig.name;
+    this.wsDescription = wsConfig.description || "";
+    if (!Array.isArray(wsConfig.panes)) wsConfig.panes = [];
+    for (const p of wsConfig.panes) {
+      const match = p.id.match(/^pane-(\d+)$/);
+      if (match) {
+        const num = parseInt(match[1], 10);
+        if (num >= paneCounter) paneCounter = num;
+      }
+    }
+    let failCount = 0;
+    for (const paneConfig of wsConfig.panes) {
+      if (paneConfig.sessionId && paneConfig.agent !== "__shell__") {
+        paneConfig.restore = "resume";
+      }
+      try {
+        this.spawnPane(paneConfig);
+      } catch (err) {
+        console.warn(`Skipping stale pane ${paneConfig.id} (${paneConfig.name}):`, err.message);
+        failCount++;
+      }
+    }
+    if (failCount > 0) {
+      wsConfig.panes = wsConfig.panes.filter((p) => this.panes.has(p.id));
+      this.configManager.saveWorkspaceConfig(wsConfig);
+    }
+  }
+  getState() {
+    return {
+      name: this.wsName,
+      description: this.wsDescription,
+      projectDir: this.configManager.getProjectDir(),
+      panes: Array.from(this.panes.values())
+    };
+  }
+  getPanes() {
+    return Array.from(this.panes.values());
+  }
+  async createPane(createConfig) {
+    const isShell = createConfig.agent === "__shell__";
+    const id = isShell ? "__shell__" : nextPaneId();
+    const isolation = createConfig.isolation || "shared";
+    const { cols, rows, ...rest } = createConfig;
+    const config = {
+      id,
+      ...rest,
+      yolo: rest.yolo || false,
+      isolation,
+      sessionId: rest.sessionId
+    };
+    if (isolation === "worktree" && !isShell) {
+      try {
+        const { worktreePath, branch } = await this.worktreeManager.create(id, createConfig.name);
+        config.worktreePath = worktreePath;
+        config.branch = branch;
+      } catch (err) {
+        console.error(`Failed to create worktree for pane ${id}:`, err);
+        throw err;
+      }
+    }
+    try {
+      const pane = this.spawnPane(config, cols, rows);
+      if (isolation === "worktree" && config.worktreePath) {
+        await this.startPaneGitService(id, config.worktreePath);
+      }
+      if (!isShell) {
+        this.persistPaneConfig(config);
+      }
+      return pane;
+    } catch (err) {
+      if (isolation === "worktree") {
+        await this.worktreeManager.removeWithBranch(id);
+      }
+      console.error(`Failed to create pane ${id}:`, err);
+      throw err;
+    }
+  }
+  async closePane(paneId) {
+    const pane = this.panes.get(paneId);
+    this.ptyManager.kill(paneId);
+    if (pane?.isolation === "worktree") {
+      this.stopPaneGitService(paneId);
+      await this.worktreeManager.remove(paneId);
+    }
+    this.panes.delete(paneId);
+    this.emit("onPaneRemoved", paneId);
+    this.removePaneFromConfig(paneId);
+  }
+  restartPane(paneId, mode, sessionId) {
+    const existingState = this.panes.get(paneId);
+    if (!existingState) return;
+    this.ptyManager.kill(paneId);
+    const resolvedSessionId = mode === "resume" ? sessionId || existingState.sessionId || existingState.meta.sessionId : void 0;
+    const config = {
+      id: paneId,
+      name: existingState.name,
+      agent: existingState.agent,
+      workdir: existingState.workdir,
+      task: existingState.task,
+      restore: mode,
+      isolation: existingState.isolation,
+      yolo: existingState.yolo || false,
+      worktreePath: existingState.worktreePath,
+      branch: existingState.branch,
+      sessionId: resolvedSessionId
+    };
+    this.spawnPane(config);
+    this.updatePaneConfigSessionId(paneId, resolvedSessionId);
+  }
+  writeToPane(paneId, data) {
+    this.ptyManager.write(paneId, data);
+  }
+  resizePane(paneId, cols, rows) {
+    this.ptyManager.resize(paneId, cols, rows);
+  }
+  getScrollback(paneId) {
+    return this.ptyManager.getScrollback(paneId);
+  }
+  // ─── Event Registration (multi-client safe) ────────────────
+  /**
+   * Register event handlers for a client. Returns a cleanup function
+   * that removes only this client's handlers.
+   */
+  onEvents(handlers) {
+    const cleanups = [];
+    for (const key of Object.keys(handlers)) {
+      const handler = handlers[key];
+      if (handler) {
+        const set = this.listeners[key];
+        set.add(handler);
+        cleanups.push(() => set.delete(handler));
+      }
+    }
+    return () => {
+      for (const cleanup of cleanups) {
+        cleanup();
+      }
+    };
+  }
+  // Broadcast events (called by services)
+  emitFileTree(tree) {
+    this.emit("onFileTree", tree);
+  }
+  emitGitDiff(result) {
+    this.emit("onGitDiff", result);
+  }
+  emitFileActivity(activity) {
+    this.emit("onFileActivity", activity);
+  }
+  async refreshPaneDiff(paneId) {
+    const gitService = this.perPaneGitServices.get(paneId);
+    if (gitService) {
+      await gitService.refresh();
+    }
+  }
+  /**
+   * Get current per-pane diffs (for initial sync on WS connect).
+   */
+  getPaneDiffs() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [paneId, gitService] of this.perPaneGitServices) {
+      result.set(paneId, gitService.getCurrentDiffs().unstaged);
+    }
+    return result;
+  }
+  // ─── Internal ─────────────────────────────────────────────
+  emit(key, ...args) {
+    const set = this.listeners[key];
+    for (const listener of set) {
+      listener(...args);
+    }
+  }
+  spawnPane(config, cols, rows) {
+    const pid = this.ptyManager.spawn(config.id, config, cols || 80, rows || 24);
+    const pane = {
+      id: config.id,
+      name: config.name,
+      agent: config.agent,
+      workdir: config.workdir,
+      task: config.task,
+      restore: config.restore,
+      isolation: config.isolation || "shared",
+      yolo: config.yolo || false,
+      branch: config.branch,
+      worktreePath: config.worktreePath,
+      sessionId: config.sessionId,
+      status: "running",
+      pid,
+      meta: {},
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.panes.set(config.id, pane);
+    this.emit("onPaneAdded", pane);
+    this.ptyManager.onData(config.id, (data) => {
+      this.emit("onTerminalData", config.id, data);
+    });
+    this.ptyManager.onStatus(config.id, (status) => {
+      const p = this.panes.get(config.id);
+      if (p) {
+        p.status = status;
+        this.emit("onPaneStatus", config.id, status);
+      }
+    });
+    this.ptyManager.onMeta(config.id, (meta) => {
+      const p = this.panes.get(config.id);
+      if (p) {
+        p.meta = meta;
+        if (meta.sessionId && meta.sessionId !== p.sessionId) {
+          p.sessionId = meta.sessionId;
+          this.updatePaneConfigSessionId(config.id, meta.sessionId);
+        }
+        this.emit("onPaneMeta", config.id, meta);
+      }
+    });
+    this.ptyManager.onActivity(config.id, (activity) => {
+      this.emit("onPaneActivity", config.id, activity);
+    });
+    return pane;
+  }
+  async startPaneGitService(paneId, worktreePath) {
+    const gitService = new GitService(worktreePath);
+    gitService.onDiffChange((result) => {
+      const tagged = result.unstaged.map((d) => ({ ...d, paneId }));
+      this.emit("onPaneDiff", paneId, tagged);
+    });
+    await gitService.start();
+    this.perPaneGitServices.set(paneId, gitService);
+  }
+  stopPaneGitService(paneId) {
+    const gitService = this.perPaneGitServices.get(paneId);
+    if (gitService) {
+      gitService.close();
+      this.perPaneGitServices.delete(paneId);
+    }
+  }
+  persistPaneConfig(config) {
+    const wsConfig = this.configManager.loadWorkspaceConfig();
+    if (wsConfig) {
+      wsConfig.panes.push(config);
+      this.configManager.saveWorkspaceConfig(wsConfig);
+    }
+  }
+  updatePaneConfigSessionId(paneId, sessionId) {
+    const wsConfig = this.configManager.loadWorkspaceConfig();
+    if (wsConfig) {
+      const paneConfig = wsConfig.panes.find((p) => p.id === paneId);
+      if (paneConfig) {
+        paneConfig.sessionId = sessionId;
+        this.configManager.saveWorkspaceConfig(wsConfig);
+      }
+    }
+  }
+  getSessionList(paneId) {
+    const sessions = [];
+    for (const pane of this.panes.values()) {
+      if (pane.agent === "__shell__") continue;
+      if (paneId && pane.id !== paneId) continue;
+      if (pane.meta.sessionId || pane.sessionId) {
+        sessions.push({
+          sessionId: pane.meta.sessionId || pane.sessionId,
+          paneId: pane.id,
+          paneName: pane.name,
+          agent: pane.agent,
+          timestamp: pane.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+          costUsd: pane.meta.costUsd,
+          contextUsedPct: pane.meta.contextUsedPct,
+          model: pane.meta.model
+        });
+      }
+    }
+    const wsConfig = this.configManager.loadWorkspaceConfig();
+    if (wsConfig) {
+      for (const pc of wsConfig.panes) {
+        if (pc.sessionId && !sessions.find((s) => s.sessionId === pc.sessionId)) {
+          if (paneId && pc.id !== paneId) continue;
+          sessions.push({
+            sessionId: pc.sessionId,
+            paneId: pc.id,
+            paneName: pc.name,
+            agent: pc.agent,
+            timestamp: ""
+          });
+        }
+      }
+    }
+    return sessions;
+  }
+  removePaneFromConfig(paneId) {
+    const wsConfig = this.configManager.loadWorkspaceConfig();
+    if (wsConfig) {
+      wsConfig.panes = wsConfig.panes.filter((p) => p.id !== paneId);
+      this.configManager.saveWorkspaceConfig(wsConfig);
+    }
+  }
+  async shutdown() {
+    this.ptyManager.killAll();
+    for (const [paneId] of this.perPaneGitServices) {
+      this.stopPaneGitService(paneId);
+    }
+    await this.worktreeManager.removeAll();
+  }
+};
+
+// src/workspace/AgentsYamlWriter.ts
+import fs4 from "fs";
+import path5 from "path";
+import yaml2 from "js-yaml";
+var AgentsYamlWriter = class {
+  projectDir;
+  debounceTimer = null;
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+  }
+  /**
+   * Write agents.yaml with current pane states. Debounced to avoid excessive writes.
+   */
+  update(panes) {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.writeFile(panes);
+    }, 500);
+  }
+  /**
+   * Write immediately without debouncing.
+   */
+  flush(panes) {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.writeFile(panes);
+  }
+  writeFile(panes) {
+    const nexusDir = path5.join(this.projectDir, ".nexus");
+    fs4.mkdirSync(nexusDir, { recursive: true });
+    const visible = panes.filter((p) => p.agent !== "__shell__");
+    const data = {
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      panes: visible.map((p) => {
+        const basePath = p.isolation === "worktree" && p.worktreePath ? p.worktreePath : this.projectDir;
+        return {
+          id: p.id,
+          name: p.name,
+          agent: p.agent,
+          pid: p.pid,
+          status: p.status,
+          isolation: p.isolation || "shared",
+          branch: p.branch || void 0,
+          workdir: p.workdir ? path5.resolve(basePath, p.workdir) : basePath,
+          task: p.task || void 0,
+          model: p.meta.model || void 0,
+          context_used_pct: p.meta.contextUsedPct ?? void 0,
+          cost_usd: p.meta.costUsd ?? void 0,
+          session_id: p.meta.sessionId || void 0,
+          started_at: p.startedAt || void 0
+        };
+      })
+    };
+    const filePath = path5.join(nexusDir, "agents.yaml");
+    fs4.writeFileSync(filePath, yaml2.dump(data, { lineWidth: -1 }));
+  }
+};
+
+// src/fs/FsWatcher.ts
+import fs5 from "fs";
+import path6 from "path";
+import { watch as watch2 } from "chokidar";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".cache",
+  ".turbo",
+  "__pycache__"
+]);
+var IGNORED_FILES = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  "Thumbs.db"
+]);
+var FsWatcher = class {
+  projectDir;
+  watcher = null;
+  tree = [];
+  debounceTimer = null;
+  listeners = /* @__PURE__ */ new Set();
+  fileChangeListeners = /* @__PURE__ */ new Set();
+  recentChanges = /* @__PURE__ */ new Map();
+  // path → timestamp for dedup
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+  }
+  start() {
+    this.tree = this.buildTree(this.projectDir, 0);
+    this.notifyListeners();
+    this.watcher = watch2(this.projectDir, {
+      ignored: (filePath) => {
+        const basename = path6.basename(filePath);
+        return IGNORED_DIRS.has(basename) || IGNORED_FILES.has(basename);
+      },
+      persistent: true,
+      ignoreInitial: true,
+      depth: 5
+    });
+    const scheduleRebuild = () => {
+      if (this.debounceTimer) clearTimeout(this.debounceTimer);
+      this.debounceTimer = setTimeout(() => {
+        const newTree = this.buildTree(this.projectDir, 0);
+        if (this.treeFingerprint(newTree) === this.treeFingerprint(this.tree)) return;
+        this.tree = newTree;
+        this.notifyListeners();
+      }, 300);
+    };
+    const emitFileChange = (eventType, filePath) => {
+      const relativePath = path6.relative(this.projectDir, filePath);
+      if (!relativePath || relativePath.startsWith("..")) return;
+      if (!/\.\w{1,10}$/.test(path6.basename(filePath))) return;
+      const now = Date.now();
+      const lastChange = this.recentChanges.get(relativePath);
+      if (lastChange && now - lastChange < 1e3) return;
+      this.recentChanges.set(relativePath, now);
+      if (this.recentChanges.size > 200) {
+        for (const [key, ts] of this.recentChanges) {
+          if (now - ts > 1e4) this.recentChanges.delete(key);
+        }
+      }
+      const actionMap = { add: "create", change: "edit", unlink: "delete" };
+      const activity = {
+        file: relativePath,
+        action: actionMap[eventType],
+        timestamp: now
+      };
+      for (const listener of this.fileChangeListeners) {
+        listener(activity);
+      }
+    };
+    this.watcher.on("add", (p) => {
+      emitFileChange("add", p);
+      scheduleRebuild();
+    });
+    this.watcher.on("change", (p) => {
+      emitFileChange("change", p);
+    });
+    this.watcher.on("unlink", (p) => {
+      emitFileChange("unlink", p);
+      scheduleRebuild();
+    });
+    this.watcher.on("addDir", scheduleRebuild);
+    this.watcher.on("unlinkDir", scheduleRebuild);
+    this.watcher.on("error", () => {
+    });
+  }
+  getTree() {
+    return this.tree;
+  }
+  onTreeChange(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  onFileChange(callback) {
+    this.fileChangeListeners.add(callback);
+    return () => this.fileChangeListeners.delete(callback);
+  }
+  close() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.watcher?.close();
+    this.watcher = null;
+  }
+  notifyListeners() {
+    for (const listener of this.listeners) {
+      listener(this.tree);
+    }
+  }
+  treeFingerprint(tree) {
+    const parts = [];
+    const walk = (nodes) => {
+      for (const n of nodes) {
+        parts.push(n.path);
+        if (n.children) walk(n.children);
+      }
+    };
+    walk(tree);
+    return parts.join("\n");
+  }
+  buildTree(dirPath, depth) {
+    if (depth > 8) return [];
+    try {
+      const entries = fs5.readdirSync(dirPath, { withFileTypes: true });
+      const nodes = [];
+      for (const entry of entries) {
+        if (IGNORED_DIRS.has(entry.name) || IGNORED_FILES.has(entry.name)) continue;
+        const fullPath = path6.join(dirPath, entry.name);
+        const relativePath = path6.relative(this.projectDir, fullPath);
+        if (entry.isDirectory()) {
+          nodes.push({
+            name: entry.name,
+            path: relativePath,
+            type: "directory",
+            children: this.buildTree(fullPath, depth + 1)
+          });
+        } else if (entry.isFile()) {
+          nodes.push({
+            name: entry.name,
+            path: relativePath,
+            type: "file"
+          });
+        }
+      }
+      nodes.sort((a, b) => {
+        if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+      return nodes;
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/ws/handlers.ts
+function setupWsHandlers(socket, workspaceManager, gitService) {
+  const send = (event) => {
+    if (socket.readyState === socket.OPEN) {
+      socket.send(JSON.stringify(event));
+    }
+  };
+  const state = workspaceManager.getState();
+  send({
+    type: "workspace.state",
+    state
+  });
+  const SCROLLBACK_CHUNK_SIZE = 64 * 1024;
+  for (const pane of state.panes) {
+    const scrollback = workspaceManager.getScrollback(pane.id);
+    if (scrollback) {
+      if (scrollback.length <= SCROLLBACK_CHUNK_SIZE) {
+        send({ type: "terminal.output", paneId: pane.id, data: scrollback });
+      } else {
+        for (let i = 0; i < scrollback.length; i += SCROLLBACK_CHUNK_SIZE) {
+          send({ type: "terminal.output", paneId: pane.id, data: scrollback.slice(i, i + SCROLLBACK_CHUNK_SIZE) });
+        }
+      }
+    }
+  }
+  const paneDiffs = workspaceManager.getPaneDiffs();
+  for (const [paneId, diffs] of paneDiffs) {
+    if (diffs.length > 0) {
+      send({ type: "pane.diff", paneId, diffs });
+    }
+  }
+  gitService?.getBranchInfo().then((info) => send({ type: "git.branchInfo", ...info })).catch(() => {
+  });
+  const cleanup = workspaceManager.onEvents({
+    onTerminalData: (paneId, data) => {
+      send({ type: "terminal.output", paneId, data });
+    },
+    onPaneStatus: (paneId, status) => {
+      send({ type: "pane.status", paneId, status });
+    },
+    onPaneMeta: (paneId, meta) => {
+      send({ type: "pane.meta", paneId, meta });
+    },
+    onPaneAdded: (pane) => {
+      send({ type: "pane.added", pane });
+    },
+    onPaneRemoved: (paneId) => {
+      send({ type: "pane.removed", paneId });
+    },
+    onPaneActivity: (paneId, activity) => {
+      send({ type: "pane.activity", paneId, activity });
+    },
+    onFileActivity: (activity) => {
+      send({ type: "file.activity", activity });
+    },
+    onPaneDiff: (paneId, diffs) => {
+      send({ type: "pane.diff", paneId, diffs });
+    },
+    onFileTree: (tree) => {
+      send({ type: "fs.tree", tree });
+    },
+    onGitDiff: (result) => {
+      send({ type: "git.diff", unstaged: result.unstaged, staged: result.staged });
+    }
+  });
+  socket.on("message", (raw) => {
+    let event;
+    try {
+      event = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    switch (event.type) {
+      case "terminal.input":
+        workspaceManager.writeToPane(event.paneId, event.data);
+        break;
+      case "terminal.resize":
+        workspaceManager.resizePane(event.paneId, event.cols, event.rows);
+        break;
+      case "pane.create":
+        workspaceManager.createPane(event.config).catch((err) => {
+          console.error("pane.create failed:", err);
+        });
+        break;
+      case "pane.close":
+        workspaceManager.closePane(event.paneId).catch((err) => {
+          console.error("pane.close failed:", err);
+        });
+        break;
+      case "pane.restart":
+        workspaceManager.restartPane(event.paneId, event.mode, event.sessionId);
+        break;
+      case "session.list":
+        send({ type: "session.list", paneId: event.paneId, sessions: workspaceManager.getSessionList(event.paneId) });
+        break;
+      case "git.refresh":
+        gitService?.refresh();
+        break;
+      case "git.accept":
+        gitService?.acceptFile(event.file).catch((err) => {
+          console.error("git.accept failed:", err);
+        });
+        break;
+      case "git.accept.all":
+        gitService?.acceptAll().catch((err) => {
+          console.error("git.accept.all failed:", err);
+        });
+        break;
+      case "git.discard":
+        gitService?.discardFile(event.file).catch((err) => {
+          console.error("git.discard failed:", err);
+        });
+        break;
+      case "git.discard.all":
+        gitService?.discardAll().catch((err) => {
+          console.error("git.discard.all failed:", err);
+        });
+        break;
+      case "git.unstage":
+        gitService?.unstageFile(event.file).catch((err) => {
+          console.error("git.unstage failed:", err);
+        });
+        break;
+      case "git.unstage.all":
+        gitService?.unstageAll().catch((err) => {
+          console.error("git.unstage.all failed:", err);
+        });
+        break;
+      case "git.commit":
+        if (gitService) {
+          gitService.commit(event.message).then((summary) => {
+            send({ type: "git.result", action: "commit", success: true, message: summary });
+            return gitService.getBranchInfo();
+          }).then((info) => {
+            send({ type: "git.branchInfo", ...info });
+          }).catch((err) => {
+            send({ type: "git.result", action: "commit", success: false, message: String(err) });
+          });
+        }
+        break;
+      case "git.push":
+        if (gitService) {
+          gitService.push().then((summary) => {
+            send({ type: "git.result", action: "push", success: true, message: summary });
+            return gitService.getBranchInfo();
+          }).then((info) => {
+            send({ type: "git.branchInfo", ...info });
+          }).catch((err) => {
+            send({ type: "git.result", action: "push", success: false, message: String(err) });
+          });
+        }
+        break;
+      case "pane.diff.refresh":
+        workspaceManager.refreshPaneDiff(event.paneId);
+        break;
+      case "workspace.save":
+        break;
+      case "review.comment": {
+        const { paneId: targetPaneId, comment } = event;
+        const targetPane = workspaceManager.getPanes().find((p) => p.id === targetPaneId);
+        if (targetPane && comment.content.trim()) {
+          const msg = [
+            "",
+            `[Review Comment] ${comment.file}:${comment.line}`,
+            comment.content.trim(),
+            ""
+          ].join("\n");
+          workspaceManager.writeToPane(targetPaneId, msg + "\n");
+        }
+        break;
+      }
+      case "broadcast.send":
+      case "task.dispatch":
+        break;
+    }
+  });
+  socket.on("close", () => {
+    cleanup();
+  });
+}
+
+// src/deps/DependencyAnalyzer.ts
+import fs6 from "fs";
+import path7 from "path";
+var IMPORT_FROM_RE = /import\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+var EXPORT_FROM_RE = /export\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+var REQUIRE_RE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var DYNAMIC_IMPORT_RE = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var JS_TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs", ".cts"]);
+var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", "", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", "coverage", ".nexus", ".turbo", ".cache"]);
+var DependencyAnalyzer = class {
+  projectDir;
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+  }
+  /**
+   * Scan the project directory and build a dependency graph.
+   * Only analyzes JS/TS files with relative imports.
+   */
+  analyze() {
+    const files = this.collectFiles(this.projectDir);
+    const nodes = [];
+    for (const absPath of files) {
+      const relPath = path7.relative(this.projectDir, absPath);
+      const imports = this.extractImports(absPath, relPath);
+      nodes.push({ id: relPath, imports });
+    }
+    return { nodes, root: this.projectDir };
+  }
+  collectFiles(dir, depth = 0) {
+    if (depth > 8) return [];
+    const files = [];
+    let entries;
+    try {
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return files;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      const fullPath = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        files.push(...this.collectFiles(fullPath, depth + 1));
+      } else if (entry.isFile()) {
+        const ext = path7.extname(entry.name);
+        if (JS_TS_EXTENSIONS.has(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+    return files;
+  }
+  extractImports(absPath, relPath) {
+    let content;
+    try {
+      content = fs6.readFileSync(absPath, "utf-8");
+    } catch {
+      return [];
+    }
+    const specifiers = /* @__PURE__ */ new Set();
+    const patterns = [IMPORT_FROM_RE, EXPORT_FROM_RE, REQUIRE_RE, DYNAMIC_IMPORT_RE];
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const spec = match[1];
+        if (spec.startsWith(".")) {
+          specifiers.add(spec);
+        }
+      }
+    }
+    const imports = [];
+    const fileDir = path7.dirname(absPath);
+    for (const spec of specifiers) {
+      const resolved = this.resolveSpecifier(fileDir, spec);
+      if (resolved) {
+        const resolvedRel = path7.relative(this.projectDir, resolved);
+        imports.push(resolvedRel);
+      }
+    }
+    return imports;
+  }
+  resolveSpecifier(fromDir, specifier) {
+    const base = path7.resolve(fromDir, specifier);
+    for (const ext of RESOLVE_EXTENSIONS) {
+      const candidate = base + ext;
+      try {
+        if (fs6.statSync(candidate).isFile()) {
+          return candidate;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+};
+
+// src/history/SessionRecorder.ts
+import fs7 from "fs";
+import path8 from "path";
+import { execFile as execFile2 } from "child_process";
+var HISTORY_DIR = ".nexus/history";
+var SESSIONS_INDEX = "sessions.json";
+var TERMINAL_BATCH_MS = 200;
+var MAX_TERMINAL_BYTES_PER_TURN = 256 * 1024;
+var MAX_SESSIONS = 50;
+var SessionRecorder = class _SessionRecorder {
+  projectDir;
+  session;
+  sessionDir;
+  activeTurns = /* @__PURE__ */ new Map();
+  // paneId -> current turn
+  turnCounter = 0;
+  retentionDays;
+  constructor(projectDir, projectName, retentionDays = 30) {
+    this.projectDir = projectDir;
+    const sessionId = `s-${Date.now()}`;
+    this.sessionDir = path8.join(projectDir, HISTORY_DIR, sessionId);
+    fs7.mkdirSync(this.sessionDir, { recursive: true });
+    this.retentionDays = retentionDays;
+    this.session = {
+      id: sessionId,
+      startedAt: Date.now(),
+      endedAt: null,
+      projectDir,
+      projectName,
+      panes: [],
+      turns: []
+      // lightweight refs only — full data in turn files
+    };
+  }
+  // ─── Event Hooks (called by WorkspaceManager wiring) ─────
+  onPaneAdded(pane) {
+    if (pane.agent === "__shell__") return;
+    const exists = this.session.panes.find((p) => p.id === pane.id);
+    if (!exists) {
+      this.session.panes.push({
+        id: pane.id,
+        name: pane.name,
+        agent: pane.agent,
+        task: pane.task
+      });
+    }
+    if (pane.status === "running") {
+      this.startTurn(pane.id, pane.name, pane.agent, pane.task);
+    }
+  }
+  onPaneRemoved(paneId) {
+    this.endTurn(paneId);
+  }
+  onPaneStatus(paneId, status, pane) {
+    if (!pane || pane.agent === "__shell__") return;
+    const active = this.activeTurns.get(paneId);
+    if (status === "running" && !active) {
+      this.startTurn(paneId, pane.name, pane.agent, pane.task);
+    } else if ((status === "idle" || status === "stopped" || status === "error") && active) {
+      this.recordStatusEvent(paneId, status);
+      this.endTurn(paneId);
+    } else if (active) {
+      this.recordStatusEvent(paneId, status);
+    }
+  }
+  onPaneMeta(paneId, meta) {
+    const active = this.activeTurns.get(paneId);
+    if (!active) return;
+    const event = {
+      t: Date.now() - active.turn.startedAt,
+      type: "meta",
+      paneId,
+      meta
+    };
+    active.turn.events.push(event);
+  }
+  onTerminalData(paneId, data) {
+    const active = this.activeTurns.get(paneId);
+    if (!active) return;
+    if (active.terminalBytes >= MAX_TERMINAL_BYTES_PER_TURN) return;
+    active.terminalBuffer += data;
+    active.terminalBytes += data.length;
+    if (!active.terminalFlushTimer) {
+      active.terminalFlushTimer = setTimeout(() => {
+        this.flushTerminalBuffer(paneId);
+      }, TERMINAL_BATCH_MS);
+    }
+  }
+  onPaneActivity(paneId, activity) {
+    const active = this.activeTurns.get(paneId);
+    if (!active) return;
+    const event = {
+      t: Date.now() - active.turn.startedAt,
+      type: "activity",
+      paneId,
+      activity: { ...activity }
+    };
+    active.turn.events.push(event);
+    switch (activity.action) {
+      case "read":
+        active.filesRead.add(activity.file);
+        break;
+      case "edit":
+      case "write":
+        active.filesEdited.add(activity.file);
+        break;
+      case "create":
+        active.filesCreated.add(activity.file);
+        break;
+    }
+    if (activity.action === "edit" || activity.action === "write" || activity.action === "create") {
+      this.captureDiff(activity.file).then((diff) => {
+        if (diff) {
+          event.activity = { ...event.activity, diff };
+        }
+      }).catch(() => {
+      });
+    }
+  }
+  /** Also accept file-level activity (from FsWatcher) attributed to the most recently active pane */
+  onFileActivityForReplay(activity) {
+    if (this.activeTurns.size === 0) return;
+    if (this.activeTurns.size !== 1) return;
+    const [paneId, active] = [...this.activeTurns.entries()][0];
+    let recentActivity;
+    for (let i = active.turn.events.length - 1; i >= 0; i--) {
+      const e = active.turn.events[i];
+      if (e.type === "activity" && e.activity?.file === activity.file) {
+        recentActivity = e;
+        break;
+      }
+    }
+    if (recentActivity && Date.now() - active.turn.startedAt - recentActivity.t < 2e3) return;
+    const event = {
+      t: Date.now() - active.turn.startedAt,
+      type: "activity",
+      paneId,
+      activity: { ...activity }
+    };
+    active.turn.events.push(event);
+    if (activity.action === "edit" || activity.action === "create") {
+      this.captureDiff(activity.file).then((diff) => {
+        if (diff) {
+          event.activity = { ...event.activity, diff };
+        }
+      }).catch(() => {
+      });
+    }
+  }
+  // ─── Session Lifecycle ────────────────────────────────────
+  /** Flush all active turns and write session index. Called on shutdown. */
+  flush() {
+    for (const paneId of [...this.activeTurns.keys()]) {
+      this.endTurn(paneId);
+    }
+    this.session.endedAt = Date.now();
+    this.writeSessionFile();
+    this.updateSessionsIndex();
+  }
+  // ─── Query API ────────────────────────────────────────────
+  static listSessions(projectDir) {
+    const indexPath = path8.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    if (!fs7.existsSync(indexPath)) return [];
+    try {
+      const data = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+  static getSession(projectDir, sessionId) {
+    const sessionPath = path8.join(projectDir, HISTORY_DIR, sessionId, "session.json");
+    if (!fs7.existsSync(sessionPath)) return null;
+    try {
+      return JSON.parse(fs7.readFileSync(sessionPath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  static getTurn(projectDir, sessionId, turnId) {
+    const turnPath = path8.join(projectDir, HISTORY_DIR, sessionId, `${turnId}.json`);
+    if (!fs7.existsSync(turnPath)) return null;
+    try {
+      return JSON.parse(fs7.readFileSync(turnPath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  /** Delete a single session and its directory. Returns true if deleted. */
+  static deleteSession(projectDir, sessionId) {
+    const sessionDir = path8.join(projectDir, HISTORY_DIR, sessionId);
+    if (fs7.existsSync(sessionDir)) {
+      fs7.rmSync(sessionDir, { recursive: true, force: true });
+    }
+    const indexPath = path8.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    if (fs7.existsSync(indexPath)) {
+      try {
+        let sessions = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+        const before = sessions.length;
+        sessions = sessions.filter((s) => s.id !== sessionId);
+        if (sessions.length < before) {
+          fs7.writeFileSync(indexPath, JSON.stringify(sessions, null, 2));
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /** Delete all sessions. Returns the number of sessions deleted. */
+  static deleteAllSessions(projectDir) {
+    const sessions = _SessionRecorder.listSessions(projectDir);
+    let count = 0;
+    for (const session of sessions) {
+      const sessionDir = path8.join(projectDir, HISTORY_DIR, session.id);
+      if (fs7.existsSync(sessionDir)) {
+        fs7.rmSync(sessionDir, { recursive: true, force: true });
+        count++;
+      }
+    }
+    const indexPath = path8.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    fs7.writeFileSync(indexPath, JSON.stringify([], null, 2));
+    return count;
+  }
+  /**
+   * Passive cleanup: prune sessions exceeding max count or older than retentionDays.
+   * Called automatically when saving a new session.
+   */
+  static pruneOldSessions(projectDir, retentionDays) {
+    const indexPath = path8.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    if (!fs7.existsSync(indexPath)) return 0;
+    let sessions;
+    try {
+      sessions = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+    } catch {
+      return 0;
+    }
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+    const keep = [];
+    const remove = [];
+    for (const s of sessions) {
+      if (s.startedAt < cutoff || keep.length >= MAX_SESSIONS) {
+        remove.push(s);
+      } else {
+        keep.push(s);
+      }
+    }
+    if (remove.length === 0) return 0;
+    for (const s of remove) {
+      const sessionDir = path8.join(projectDir, HISTORY_DIR, s.id);
+      if (fs7.existsSync(sessionDir)) {
+        fs7.rmSync(sessionDir, { recursive: true, force: true });
+      }
+    }
+    fs7.writeFileSync(indexPath, JSON.stringify(keep, null, 2));
+    return remove.length;
+  }
+  // ─── Internal ─────────────────────────────────────────────
+  startTurn(paneId, paneName, agent, task) {
+    if (this.activeTurns.has(paneId)) {
+      this.endTurn(paneId);
+    }
+    const turnId = `turn-${++this.turnCounter}`;
+    const turn = {
+      id: turnId,
+      paneId,
+      paneName,
+      agent,
+      startedAt: Date.now(),
+      endedAt: null,
+      task,
+      events: [],
+      summary: {
+        filesRead: 0,
+        filesEdited: 0,
+        filesCreated: 0,
+        terminalBytes: 0,
+        durationMs: 0
+      }
+    };
+    this.activeTurns.set(paneId, {
+      turn,
+      terminalBuffer: "",
+      terminalFlushTimer: null,
+      terminalBytes: 0,
+      filesRead: /* @__PURE__ */ new Set(),
+      filesEdited: /* @__PURE__ */ new Set(),
+      filesCreated: /* @__PURE__ */ new Set()
+    });
+  }
+  endTurn(paneId) {
+    const active = this.activeTurns.get(paneId);
+    if (!active) return;
+    this.flushTerminalBuffer(paneId);
+    const turn = active.turn;
+    turn.endedAt = Date.now();
+    turn.summary = {
+      filesRead: active.filesRead.size,
+      filesEdited: active.filesEdited.size,
+      filesCreated: active.filesCreated.size,
+      terminalBytes: active.terminalBytes,
+      durationMs: turn.endedAt - turn.startedAt
+    };
+    if (turn.events.length > 0) {
+      this.writeTurnFile(turn);
+      this.session.turns.push({
+        ...turn,
+        events: []
+        // don't duplicate events in session file
+      });
+    }
+    this.activeTurns.delete(paneId);
+  }
+  recordStatusEvent(paneId, status) {
+    const active = this.activeTurns.get(paneId);
+    if (!active) return;
+    active.turn.events.push({
+      t: Date.now() - active.turn.startedAt,
+      type: "status",
+      paneId,
+      status
+    });
+  }
+  flushTerminalBuffer(paneId) {
+    const active = this.activeTurns.get(paneId);
+    if (!active || !active.terminalBuffer) return;
+    if (active.terminalFlushTimer) {
+      clearTimeout(active.terminalFlushTimer);
+      active.terminalFlushTimer = null;
+    }
+    active.turn.events.push({
+      t: Date.now() - active.turn.startedAt,
+      type: "terminal",
+      paneId,
+      data: active.terminalBuffer
+    });
+    active.terminalBuffer = "";
+  }
+  /** Capture git diff for a single file. Returns unified diff string or null. */
+  captureDiff(file) {
+    return new Promise((resolve) => {
+      execFile2("git", ["diff", "--no-color", "-U3", "--", file], {
+        cwd: this.projectDir,
+        timeout: 3e3,
+        maxBuffer: 128 * 1024
+      }, (err, stdout) => {
+        if (stdout && stdout.trim()) {
+          resolve(stdout.trim());
+          return;
+        }
+        execFile2("git", ["diff", "--no-color", "--no-index", "/dev/null", file], {
+          cwd: this.projectDir,
+          timeout: 3e3,
+          maxBuffer: 128 * 1024
+        }, (_err2, stdout2) => {
+          resolve(stdout2?.trim() || null);
+        });
+      });
+    });
+  }
+  writeTurnFile(turn) {
+    const turnPath = path8.join(this.sessionDir, `${turn.id}.json`);
+    fs7.writeFileSync(turnPath, JSON.stringify(turn));
+  }
+  writeSessionFile() {
+    const sessionPath = path8.join(this.sessionDir, "session.json");
+    fs7.writeFileSync(sessionPath, JSON.stringify(this.session, null, 2));
+  }
+  updateSessionsIndex() {
+    const indexPath = path8.join(this.projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    let sessions = [];
+    if (fs7.existsSync(indexPath)) {
+      try {
+        sessions = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+      } catch {
+      }
+    }
+    const totalDurationMs = this.session.endedAt ? this.session.endedAt - this.session.startedAt : 0;
+    sessions.unshift({
+      id: this.session.id,
+      startedAt: this.session.startedAt,
+      endedAt: this.session.endedAt,
+      projectName: this.session.projectName,
+      turnCount: this.session.turns.length,
+      paneCount: this.session.panes.length,
+      totalDurationMs
+    });
+    fs7.writeFileSync(indexPath, JSON.stringify(sessions, null, 2));
+    const pruned = _SessionRecorder.pruneOldSessions(this.projectDir, this.retentionDays);
+    if (pruned > 0) {
+      console.log(`[SessionRecorder] Pruned ${pruned} old session(s)`);
+    }
+  }
+};
+
+// src/workspace/SessionDiscovery.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile3);
+var CACHE_TTL = 3e4;
+var SessionDiscovery = class {
+  configManager;
+  cache = null;
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+  async listSessions(agentType = "claudecode") {
+    const now = Date.now();
+    if (this.cache && now - this.cache.ts < CACHE_TTL) {
+      return this.cache.sessions;
+    }
+    const sessions = await this.fetchSessions(agentType);
+    this.cache = { sessions, ts: now };
+    return sessions;
+  }
+  async fetchSessions(agentType) {
+    const agentDef = this.configManager.getAgentDefinition(agentType);
+    if (!agentDef || agentDef.bin !== "claude") {
+      return [];
+    }
+    try {
+      const { stdout } = await execFileAsync2(agentDef.bin, ["sessions", "list", "--output", "json"], {
+        timeout: 1e4,
+        env: { ...process.env }
+      });
+      const parsed = JSON.parse(stdout.trim());
+      const items = Array.isArray(parsed) ? parsed : parsed.sessions || [];
+      return items.map((s) => ({
+        sessionId: s.session_id,
+        summary: s.summary,
+        model: s.model,
+        costUsd: s.cost_usd,
+        numTurns: s.num_turns,
+        createdAt: s.created_at,
+        updatedAt: s.updated_at,
+        projectPath: s.project_path,
+        source: "external"
+      }));
+    } catch (err) {
+      console.warn("[SessionDiscovery] Failed to list sessions:", err.message);
+      return [];
+    }
+  }
+};
+
+// src/index.ts
+var __dirname = path9.dirname(fileURLToPath(import.meta.url));
+async function startServer(port, projectDir) {
+  const fastify = Fastify({ logger: false });
+  const configManager = new ConfigManager(projectDir);
+  configManager.loadGlobalConfig();
+  const workspaceManager = new WorkspaceManager(configManager);
+  workspaceManager.init();
+  const agentsWriter = new AgentsYamlWriter(projectDir);
+  workspaceManager.onEvents({
+    onPaneAdded: () => agentsWriter.update(workspaceManager.getPanes()),
+    onPaneRemoved: () => agentsWriter.update(workspaceManager.getPanes()),
+    onPaneStatus: () => agentsWriter.update(workspaceManager.getPanes()),
+    onPaneMeta: () => agentsWriter.update(workspaceManager.getPanes())
+  });
+  const wsConfig = configManager.loadWorkspaceConfig();
+  const globalConfig = configManager.loadGlobalConfig();
+  const recorder = new SessionRecorder(projectDir, wsConfig?.name || "Nexus", globalConfig.defaults.history_retention_days);
+  workspaceManager.onEvents({
+    onPaneAdded: (pane) => recorder.onPaneAdded(pane),
+    onPaneRemoved: (paneId) => recorder.onPaneRemoved(paneId),
+    onPaneStatus: (paneId, status) => {
+      const panes = workspaceManager.getPanes();
+      const pane = panes.find((p) => p.id === paneId);
+      recorder.onPaneStatus(paneId, status, pane);
+    },
+    onPaneMeta: (paneId, meta) => recorder.onPaneMeta(paneId, meta),
+    onTerminalData: (paneId, data) => recorder.onTerminalData(paneId, data),
+    onPaneActivity: (paneId, activity) => recorder.onPaneActivity(paneId, activity)
+  });
+  const fsWatcher = new FsWatcher(projectDir);
+  fsWatcher.onTreeChange((tree) => {
+    workspaceManager.emitFileTree(tree);
+  });
+  fsWatcher.onFileChange((activity) => {
+    workspaceManager.emitFileActivity(activity);
+    recorder.onFileActivityForReplay(activity);
+  });
+  try {
+    fsWatcher.start();
+  } catch (err) {
+    console.warn("[FsWatcher] Failed to start file watcher:", err.message);
+  }
+  const gitService = new GitService(projectDir);
+  gitService.onDiffChange((result) => {
+    workspaceManager.emitGitDiff(result);
+  });
+  try {
+    await gitService.start();
+  } catch (err) {
+    console.warn("[GitService] Failed to start git service:", err.message);
+  }
+  await fastify.register(fastifyWebsocket);
+  fastify.get("/nexus-ws", { websocket: true }, (socket, req) => {
+    console.log("[WS] Upgrade request from", req.ip);
+    try {
+      setupWsHandlers(socket, workspaceManager, gitService);
+      const tree = fsWatcher.getTree();
+      if (tree.length > 0) {
+        socket.send(JSON.stringify({ type: "fs.tree", tree }));
+      }
+      const { unstaged, staged } = gitService.getCurrentDiffs();
+      if (unstaged.length > 0 || staged.length > 0) {
+        socket.send(JSON.stringify({ type: "git.diff", unstaged, staged }));
+      }
+      console.log("[WS] Client connected");
+      socket.on("close", (code, reason) => {
+        console.log(`[WS] Client disconnected: code=${code} reason=${reason.toString()}`);
+      });
+      socket.on("error", (err) => {
+        console.error("[WS] Socket error:", err);
+      });
+    } catch (err) {
+      console.error("[WS] Error in connection handler:", err);
+    }
+  });
+  fastify.get("/api/health", async () => {
+    return { status: "ok" };
+  });
+  fastify.get("/api/agents", async () => {
+    return await configManager.checkAgentAvailability();
+  });
+  fastify.get("/api/config", async () => {
+    return configManager.loadGlobalConfig();
+  });
+  fastify.put("/api/config", async (request, reply) => {
+    try {
+      const config = request.body;
+      configManager.updateGlobalConfig(config);
+      return { success: true };
+    } catch (err) {
+      reply.code(400);
+      return { error: "Invalid config" };
+    }
+  });
+  const sessionDiscovery = new SessionDiscovery(configManager);
+  fastify.get("/api/sessions", async (request) => {
+    const { agent } = request.query;
+    const external = await sessionDiscovery.listSessions(agent || "claudecode");
+    const internal = workspaceManager.getSessionList();
+    const seen = new Set(internal.map((s2) => s2.sessionId));
+    const merged = [
+      ...internal.map((s2) => ({
+        sessionId: s2.sessionId,
+        summary: s2.paneName,
+        model: s2.model,
+        costUsd: s2.costUsd,
+        numTurns: void 0,
+        createdAt: s2.timestamp,
+        updatedAt: s2.timestamp,
+        projectPath: void 0,
+        source: "nexus"
+      })),
+      ...external.filter((s2) => !seen.has(s2.sessionId))
+    ];
+    return merged;
+  });
+  fastify.get("/api/replay/sessions", async () => {
+    return SessionRecorder.listSessions(projectDir);
+  });
+  fastify.get("/api/replay/sessions/:sessionId", async (request, reply) => {
+    const { sessionId } = request.params;
+    const session = SessionRecorder.getSession(projectDir, sessionId);
+    if (!session) {
+      reply.code(404);
+      return { error: "Session not found" };
+    }
+    return session;
+  });
+  fastify.get("/api/replay/sessions/:sessionId/turns/:turnId", async (request, reply) => {
+    const { sessionId, turnId } = request.params;
+    const turn = SessionRecorder.getTurn(projectDir, sessionId, turnId);
+    if (!turn) {
+      reply.code(404);
+      return { error: "Turn not found" };
+    }
+    return turn;
+  });
+  fastify.delete("/api/replay/sessions/:sessionId", async (request) => {
+    const { sessionId } = request.params;
+    const deleted = SessionRecorder.deleteSession(projectDir, sessionId);
+    return { success: deleted };
+  });
+  fastify.delete("/api/replay/sessions", async () => {
+    const count = SessionRecorder.deleteAllSessions(projectDir);
+    return { success: true, deleted: count };
+  });
+  let depGraphCache = null;
+  const DEP_CACHE_TTL = 3e4;
+  fastify.get("/api/deps", async () => {
+    const now = Date.now();
+    if (depGraphCache && now - depGraphCache.ts < DEP_CACHE_TTL) {
+      return depGraphCache.graph;
+    }
+    const analyzer = new DependencyAnalyzer(projectDir);
+    const graph = analyzer.analyze();
+    depGraphCache = { graph, ts: now };
+    return graph;
+  });
+  fastify.get("/api/file", async (request, reply) => {
+    const { path: filePath } = request.query;
+    if (!filePath) {
+      reply.code(400);
+      return { error: "Missing path parameter" };
+    }
+    if (filePath.includes("..") || path9.isAbsolute(filePath)) {
+      reply.code(403);
+      return { error: "Invalid path" };
+    }
+    const fullPath = path9.resolve(projectDir, filePath);
+    if (!fullPath.startsWith(projectDir)) {
+      reply.code(403);
+      return { error: "Path traversal not allowed" };
+    }
+    try {
+      const content = fs8.readFileSync(fullPath, "utf-8");
+      return { content, path: filePath };
+    } catch {
+      reply.code(404);
+      return { error: "File not found" };
+    }
+  });
+  fastify.get("/api/file/raw", async (request, reply) => {
+    const { path: filePath } = request.query;
+    if (!filePath) {
+      reply.code(400);
+      return { error: "Missing path parameter" };
+    }
+    if (filePath.includes("..") || path9.isAbsolute(filePath)) {
+      reply.code(403);
+      return { error: "Invalid path" };
+    }
+    const fullPath = path9.resolve(projectDir, filePath);
+    if (!fullPath.startsWith(projectDir)) {
+      reply.code(403);
+      return { error: "Path traversal not allowed" };
+    }
+    if (!fs8.existsSync(fullPath)) {
+      reply.code(404);
+      return { error: "File not found" };
+    }
+    const ext = path9.extname(fullPath).toLowerCase();
+    const mimeMap = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".ico": "image/x-icon",
+      ".bmp": "image/bmp",
+      ".avif": "image/avif",
+      ".pdf": "application/pdf",
+      ".svg": "image/svg+xml"
+    };
+    const mime = mimeMap[ext] || "application/octet-stream";
+    const stream = fs8.createReadStream(fullPath);
+    reply.type(mime);
+    return reply.send(stream);
+  });
+  const notesPath = path9.join(projectDir, ".nexus", "notes.yaml");
+  fastify.get("/api/notes", async () => {
+    try {
+      const raw = fs8.readFileSync(notesPath, "utf-8");
+      const data = yaml3.load(raw);
+      return { notes: data?.notes || [] };
+    } catch {
+      return { notes: [] };
+    }
+  });
+  fastify.put("/api/notes", async (request, reply) => {
+    try {
+      const { notes } = request.body;
+      fs8.mkdirSync(path9.dirname(notesPath), { recursive: true });
+      fs8.writeFileSync(notesPath, yaml3.dump({ notes }, { lineWidth: -1 }), "utf-8");
+      return { success: true };
+    } catch (err) {
+      reply.code(400);
+      return { error: "Failed to save notes" };
+    }
+  });
+  const webDistPath = path9.resolve(__dirname, "../../web/dist");
+  if (!fs8.existsSync(webDistPath)) {
+    console.warn(`  [Warning] Frontend not found at ${webDistPath}`);
+    console.warn(`  Run 'pnpm run build:web' to build the frontend, or use dev mode.`);
+  }
+  if (fs8.existsSync(webDistPath)) {
+    await fastify.register(fastifyStatic, {
+      root: webDistPath,
+      prefix: "/"
+    });
+    fastify.setNotFoundHandler((_req, reply) => {
+      reply.sendFile("index.html");
+    });
+  }
+  const shutdown = async () => {
+    console.log("\nShutting down...");
+    recorder.flush();
+    agentsWriter.flush(workspaceManager.getPanes());
+    fsWatcher.close();
+    gitService.close();
+    await workspaceManager.shutdown();
+    await fastify.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await fastify.listen({ port, host: "0.0.0.0" });
+  } catch (err) {
+    if (err.code === "EADDRINUSE") {
+      console.error(`Port ${port} is already in use. Kill the existing process or use a different port:`);
+      console.error(`  NEXUS_PORT=7800 pnpm dev`);
+      console.error(`  # or find and kill: lsof -i :${port}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  console.log(`Nexus server running at http://localhost:${port}`);
+  console.log(`  Project dir: ${projectDir}`);
+  console.log(`  File tree: ${fsWatcher.getTree().length} top-level entries`);
+  const { unstaged: u, staged: s } = gitService.getCurrentDiffs();
+  console.log(`  Git diffs: ${u.length} unstaged, ${s.length} staged`);
+  return { fastify, workspaceManager, configManager };
+}
+
+// src/cli.ts
+var nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeVersion < 22) {
+  console.error(`Error: Nexus requires Node.js >= 22, but you are running v${process.versions.node}`);
+  console.error(`  Please upgrade: nvm install 22 && nvm use 22`);
+  process.exit(1);
+}
+delete process.env.CLAUDECODE;
+delete process.env.CLAUDE_CODE;
+delete process.env.CLAUDE_CODE_ENTRYPOINT;
+var DEFAULT_PORT = 7700;
+function printUsage() {
+  console.log(`
+  Usage: nexus [command] [directory]
+
+  Commands:
+    start [dir]    Start the Nexus server (default)
+    init  [dir]    Initialize .nexus/ config in a project
+    status [dir]   Show workspace status
+    stop           Stop the running server
+
+  Arguments:
+    dir            Path to the project directory (defaults to cwd)
+
+  Environment:
+    NEXUS_PORT     Server port (default: ${DEFAULT_PORT})
+
+  Examples:
+    nexus                        # Start in current directory
+    nexus ~/projects/my-app      # Start with a specific project
+    nexus start ~/projects/app   # Explicit start command
+    nexus init .                 # Initialize config in cwd
+`.trimEnd());
+}
+function findProjectRoot(startDir) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  let dir = startDir;
+  let bestMatch = startDir;
+  while (dir !== path10.dirname(dir)) {
+    if (fs9.existsSync(path10.join(dir, "pnpm-workspace.yaml"))) {
+      return dir;
+    }
+    if (fs9.existsSync(path10.join(dir, ".git")) || fs9.existsSync(path10.join(dir, ".nexus"))) {
+      bestMatch = dir;
+    }
+    const parent = path10.dirname(dir);
+    if (home && parent === home && dir !== startDir) break;
+    dir = parent;
+  }
+  if (home && bestMatch === home && startDir === home) {
+    console.warn(`Warning: Running Nexus in HOME directory (${home}).`);
+    console.warn(`  Consider: nexus <project-path>`);
+  }
+  return bestMatch;
+}
+function resolveProjectDir(dirArg) {
+  if (process.env.NEXUS_PROJECT_DIR) {
+    return path10.resolve(process.env.NEXUS_PROJECT_DIR);
+  }
+  if (dirArg) {
+    const resolved = path10.resolve(dirArg);
+    if (!fs9.existsSync(resolved)) {
+      console.error(`Error: directory does not exist: ${resolved}`);
+      process.exit(1);
+    }
+    if (!fs9.statSync(resolved).isDirectory()) {
+      console.error(`Error: not a directory: ${resolved}`);
+      process.exit(1);
+    }
+    return resolved;
+  }
+  return findProjectRoot(process.cwd());
+}
+var COMMANDS = /* @__PURE__ */ new Set(["start", "init", "status", "stop", "help"]);
+async function main() {
+  const args = process.argv.slice(2);
+  let command;
+  let dirArg;
+  if (args.length === 0) {
+    command = "start";
+  } else if (args[0] === "--help" || args[0] === "-h") {
+    command = "help";
+  } else if (COMMANDS.has(args[0])) {
+    command = args[0];
+    dirArg = args[1];
+  } else {
+    command = "start";
+    dirArg = args[0];
+  }
+  if (command === "help") {
+    printUsage();
+    return;
+  }
+  const projectDir = resolveProjectDir(dirArg);
+  switch (command) {
+    case "start": {
+      const port = parseInt(process.env.NEXUS_PORT || String(DEFAULT_PORT), 10);
+      await startServer(port, projectDir);
+      const url = `http://localhost:${port}`;
+      import("open").then((mod) => mod.default(url)).catch(() => {
+      });
+      const { ConfigManager: CM } = await Promise.resolve().then(() => (init_ConfigManager(), ConfigManager_exports));
+      const cm = new CM(projectDir);
+      cm.loadGlobalConfig();
+      cm.checkAgentAvailability().then((availability) => {
+        const missing = Object.entries(availability).filter(([, a]) => !a.installed);
+        if (missing.length > 0) {
+          console.log("\n  Optional agents not found:");
+          for (const [key, info] of missing) {
+            console.log(`    \u26A0 ${key} (${info.bin}) \u2014 install: ${info.installHint}`);
+          }
+          console.log();
+        }
+      }).catch(() => {
+      });
+      break;
+    }
+    case "init": {
+      const { ConfigManager: ConfigManager2 } = await Promise.resolve().then(() => (init_ConfigManager(), ConfigManager_exports));
+      const configManager = new ConfigManager2(projectDir);
+      configManager.loadGlobalConfig();
+      configManager.initWorkspace();
+      console.log(`Initialized .nexus/ in ${projectDir}`);
+      break;
+    }
+    case "status": {
+      const { ConfigManager: ConfigManager2 } = await Promise.resolve().then(() => (init_ConfigManager(), ConfigManager_exports));
+      const configManager = new ConfigManager2(projectDir);
+      const wsConfig = configManager.loadWorkspaceConfig();
+      if (!wsConfig) {
+        console.log("No .nexus/config.yaml found. Run `nexus init` first.");
+        break;
+      }
+      console.log(`Workspace: ${wsConfig.name}`);
+      console.log(`Panes: ${wsConfig.panes.length}`);
+      for (const pane of wsConfig.panes) {
+        console.log(`  - ${pane.id} [${pane.agent}] ${pane.name}${pane.task ? ` \u2014 ${pane.task}` : ""}`);
+      }
+      break;
+    }
+    case "stop": {
+      try {
+        const port = parseInt(process.env.NEXUS_PORT || String(DEFAULT_PORT), 10);
+        const res = await fetch(`http://localhost:${port}/api/health`);
+        if (res.ok) {
+          console.log("Sending shutdown signal...");
+          process.kill(process.pid, "SIGTERM");
+        }
+      } catch {
+        console.log("No running Nexus server found.");
+      }
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      printUsage();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.mjs.map