mexus-cli 1.0.0 → 1.0.2

package/packages/server/dist/cli.mjs

@@ -43,13 +43,43 @@ var init_ConfigManager = __esm({
           resume_flag: "--resume",
           yolo_flag: "--dangerously-skip-permissions",
           statusline: true,
+          transport: "pty",
+          env: {}
+        },
+        codex: {
+          bin: "codex",
+          continue_flag: "",
+          resume_flag: "",
+          yolo_flag: "",
+          statusline: false,
+          transport: "pty",
           env: {}
         },
         opencode: {
           bin: "opencode",
           continue_flag: "--continue",
+          resume_flag: "",
           yolo_flag: "--yolo",
           statusline: false,
+          transport: "acp",
+          env: {}
+        },
+        "kimi-cli": {
+          bin: "kimi",
+          continue_flag: "--continue",
+          resume_flag: "",
+          yolo_flag: "",
+          statusline: false,
+          transport: "pty",
+          env: {}
+        },
+        qodercli: {
+          bin: "qodercli",
+          continue_flag: "-c",
+          resume_flag: "-r",
+          yolo_flag: "--yolo",
+          statusline: false,
+          transport: "pty",
           env: {}
         }
       }
@@ -143,11 +173,11 @@ var init_ConfigManager = __esm({
       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 }
+          { key: "claudecode", bin: "claude", flag: "--continue", statusline: true, transport: "pty" },
+          { key: "codex", bin: "codex", flag: "", statusline: false, transport: "pty" },
+          { key: "opencode", bin: "opencode", flag: "--continue", statusline: false, transport: "acp" },
+          { key: "kimi-cli", bin: "kimi", flag: "--continue", statusline: false, transport: "pty" },
+          { key: "qodercli", bin: "qodercli", flag: "-c", statusline: false, transport: "pty" }
         ];
         const results = await Promise.allSettled(
           agentBins.map(async (agent) => {
@@ -162,6 +192,7 @@ var init_ConfigManager = __esm({
               bin: agent.bin,
               continue_flag: agent.flag,
               statusline: agent.statusline,
+              transport: agent.transport,
               env: {}
             };
           }
@@ -210,7 +241,7 @@ var init_ConfigManager = __esm({
           { 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" }
+          { key: "qodercli", bin: "qodercli", installHint: "See https://docs.qoder.com/zh/cli/using-cli" }
         ];
         const checks = await Promise.allSettled(
           knownAgents.map(async (agent) => {
@@ -245,16 +276,16 @@ var init_ConfigManager = __esm({
 });
 
 // src/cli.ts
-import path10 from "path";
-import fs9 from "fs";
+import path11 from "path";
+import fs10 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 path10 from "path";
+import fs9 from "fs";
 import yaml3 from "js-yaml";
 import { fileURLToPath } from "url";
 
@@ -275,6 +306,7 @@ var KNOWN_FIELDS = {
   // Claude Code may add more fields — add them here as discovered
 };
 var MIN_KNOWN_FIELDS = 2;
+var MAX_BUFFER_SIZE = 64 * 1024;
 var StatuslineParser = class {
   buffer = "";
   /**
@@ -286,6 +318,9 @@ var StatuslineParser = class {
     let meta = null;
     if (!data.includes("\n")) {
       this.buffer += data;
+      if (this.buffer.length > MAX_BUFFER_SIZE) {
+        this.buffer = "";
+      }
       return { cleanData: data, meta: null };
     }
     const combined = this.buffer + data;
@@ -681,7 +716,8 @@ var OutputStateAnalyzer = class {
 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 {
+var MAX_BUFFER_SIZE2 = 64 * 1024;
+var ActivityParser = class _ActivityParser {
   buffer = "";
   lastFile = "";
   lastTime = 0;
@@ -690,6 +726,9 @@ var ActivityParser = class {
   parse(data) {
     if (!data.includes("\n")) {
       this.buffer += data;
+      if (this.buffer.length > MAX_BUFFER_SIZE2) {
+        this.buffer = "";
+      }
       return null;
     }
     const lines = (this.buffer + data).split("\n");
@@ -796,10 +835,15 @@ var ActivityParser = class {
   cleanPath(raw) {
     return raw.trim().replace(/^['"`]+|['"`]+$/g, "").replace(/^\.\//, "").replace(/\s+.*$/, "").replace(/[,;:)]+$/, "").replace(/^\(/, "");
   }
+  // Paths under these prefixes are Nexus internals or noise — ignore them
+  static IGNORED_PREFIXES = [".nexus/", "node_modules/", ".git/"];
   isValidPath(file) {
     if (!file || file.length < 3) return false;
     if (!/\.\w{1,10}$/.test(file)) return false;
     if (file.startsWith("/") || file.includes("://")) return false;
+    for (const prefix of _ActivityParser.IGNORED_PREFIXES) {
+      if (file.startsWith(prefix)) return false;
+    }
     if (/[<>|&$`\\{}[\]]/.test(file)) return false;
     const parts = file.split("/");
     if (parts.length > 15) return false;
@@ -847,7 +891,19 @@ var PtyManager = class {
       }
     }
     if (agentDef?.env) {
+      const BLOCKED_ENV_KEYS = /* @__PURE__ */ new Set([
+        "PATH",
+        "LD_PRELOAD",
+        "LD_LIBRARY_PATH",
+        "DYLD_INSERT_LIBRARIES",
+        "DYLD_LIBRARY_PATH",
+        "DYLD_FRAMEWORK_PATH"
+      ]);
       for (const [key, value] of Object.entries(agentDef.env)) {
+        if (BLOCKED_ENV_KEYS.has(key)) {
+          console.warn(`[PTY] Ignoring blocked env var from agent config: ${key}`);
+          continue;
+        }
         const resolved = value.replace(/\$\{(\w+)\}/g, (_, varName) => {
           return process.env[varName] || "";
         });
@@ -913,9 +969,17 @@ var PtyManager = class {
         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;
+        if (entry.scrollbackBytes > MAX_SCROLLBACK_BYTES) {
+          let bytesToRemove = entry.scrollbackBytes - MAX_SCROLLBACK_BYTES;
+          let removeCount = 0;
+          while (removeCount < entry.scrollback.length - 1 && bytesToRemove > 0) {
+            bytesToRemove -= entry.scrollback[removeCount].length;
+            entry.scrollbackBytes -= entry.scrollback[removeCount].length;
+            removeCount++;
+          }
+          if (removeCount > 0) {
+            entry.scrollback.splice(0, removeCount);
+          }
         }
         for (const cb of entry.onDataCallbacks) {
           cb(cleanData);
@@ -1012,6 +1076,10 @@ var PtyManager = class {
       entry.shellDetector?.dispose();
       entry.agentDetector?.dispose();
       entry.parser.reset();
+      entry.onDataCallbacks.length = 0;
+      entry.onStatusCallbacks.length = 0;
+      entry.onMetaCallbacks.length = 0;
+      entry.onActivityCallbacks.length = 0;
       try {
         entry.pty.kill();
       } catch {
@@ -1067,9 +1135,368 @@ var PtyManager = class {
   }
 };
 
-// src/git/WorktreeManager.ts
-import path3 from "path";
+// src/runtime/AcpRuntime.ts
+import { spawn as spawn2 } from "child_process";
 import fs3 from "fs";
+import os3 from "os";
+import path3 from "path";
+var MAX_SCROLLBACK_BYTES2 = 512 * 1024;
+function resolveAgentEnv(agentDef) {
+  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) {
+    const blocked = /* @__PURE__ */ new Set([
+      "PATH",
+      "LD_PRELOAD",
+      "LD_LIBRARY_PATH",
+      "DYLD_INSERT_LIBRARIES",
+      "DYLD_LIBRARY_PATH",
+      "DYLD_FRAMEWORK_PATH"
+    ]);
+    for (const [key, value] of Object.entries(agentDef.env)) {
+      if (blocked.has(key)) continue;
+      env[key] = value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || "");
+    }
+  }
+  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}`;
+    }
+  }
+  return env;
+}
+var AcpRuntime = class {
+  entries = /* @__PURE__ */ new Map();
+  configManager;
+  constructor(configManager) {
+    this.configManager = configManager;
+  }
+  spawn(paneId, config) {
+    if (this.entries.has(paneId)) {
+      this.kill(paneId);
+    }
+    const projectDir = this.configManager.getProjectDir();
+    const basePath = config.isolation === "worktree" && config.worktreePath ? config.worktreePath : projectDir;
+    let cwd = config.workdir ? path3.resolve(basePath, config.workdir) : basePath;
+    if (!fs3.existsSync(cwd)) {
+      cwd = fs3.existsSync(projectDir) ? projectDir : os3.homedir();
+    }
+    const agentDef = this.configManager.getAgentDefinition(config.agent);
+    if (!agentDef) {
+      throw new Error(`Missing agent definition for ${config.agent}`);
+    }
+    const env = resolveAgentEnv(agentDef);
+    const proc = spawn2(agentDef.bin, ["acp"], {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const entry = {
+      proc,
+      config,
+      status: "running",
+      meta: { cwd },
+      nextRequestId: 1,
+      nextMessageId: 1,
+      nextToolId: 1,
+      pending: /* @__PURE__ */ new Map(),
+      stdoutBuffer: "",
+      scrollback: [],
+      scrollbackBytes: 0,
+      onDataCallbacks: [],
+      onStatusCallbacks: [],
+      onMetaCallbacks: [],
+      onConversationCallbacks: [],
+      onActivityCallbacks: []
+    };
+    this.entries.set(paneId, entry);
+    proc.stdout.setEncoding("utf8");
+    proc.stderr.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => this.handleStdout(paneId, chunk));
+    proc.stderr.on("data", (chunk) => {
+      this.emitTerminal(paneId, `[acp stderr] ${chunk}`);
+    });
+    proc.on("exit", (code, signal) => {
+      const e = this.entries.get(paneId);
+      if (!e) return;
+      for (const pending of e.pending.values()) {
+        pending.reject(new Error(`ACP process exited (${code ?? "null"}${signal ? `, ${signal}` : ""})`));
+      }
+      e.pending.clear();
+      this.setStatus(paneId, code === 0 ? "stopped" : "error");
+    });
+    this.bootstrap(paneId, cwd, config).catch((err) => {
+      this.emitTerminal(paneId, `[acp error] ${err.message}
+`);
+      this.setStatus(paneId, "error");
+    });
+    return proc.pid;
+  }
+  async bootstrap(paneId, cwd, config) {
+    const initResult = await this.request(paneId, "initialize", {
+      protocolVersion: 1,
+      clientInfo: { name: "nexus", version: "0.1.0" },
+      clientCapabilities: {}
+    });
+    const loadedSessionId = config.restore === "resume" && config.sessionId ? await this.tryLoadSession(paneId, config.sessionId) : null;
+    const sessionResult = loadedSessionId ? { sessionId: loadedSessionId } : await this.request(paneId, "session/new", {
+      cwd
+    });
+    const sessionId = this.extractSessionId(sessionResult) || this.extractSessionId(initResult) || config.sessionId;
+    if (sessionId) {
+      this.updateMeta(paneId, { sessionId, cwd });
+    } else {
+      this.updateMeta(paneId, { cwd });
+    }
+    this.emitConversation(paneId, { type: "status", status: "idle" });
+    this.setStatus(paneId, "idle");
+    if (config.task && config.restore !== "manual") {
+      await this.sendPrompt(paneId, config.task);
+    }
+  }
+  async tryLoadSession(paneId, sessionId) {
+    try {
+      const result = await this.request(paneId, "session/load", { sessionId });
+      return this.extractSessionId(result) || sessionId;
+    } catch {
+      return null;
+    }
+  }
+  async sendPrompt(paneId, text) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    const sessionId = entry.meta.sessionId || entry.config.sessionId;
+    const messageId = `user-${entry.nextMessageId++}`;
+    this.emitConversation(paneId, { type: "message", messageId, role: "user", text });
+    this.emitTerminal(paneId, `
+> ${text}
+
+`);
+    this.setStatus(paneId, "running");
+    this.emitConversation(paneId, { type: "status", status: "running" });
+    const params = {
+      prompt: [{ type: "text", text }]
+    };
+    if (sessionId) params.sessionId = sessionId;
+    await this.request(paneId, "session/prompt", params);
+  }
+  onData(paneId, cb) {
+    const entry = this.entries.get(paneId);
+    if (entry) entry.onDataCallbacks.push(cb);
+  }
+  onStatus(paneId, cb) {
+    const entry = this.entries.get(paneId);
+    if (entry) entry.onStatusCallbacks.push(cb);
+  }
+  onMeta(paneId, cb) {
+    const entry = this.entries.get(paneId);
+    if (entry) entry.onMetaCallbacks.push(cb);
+  }
+  onConversation(paneId, cb) {
+    const entry = this.entries.get(paneId);
+    if (entry) entry.onConversationCallbacks.push(cb);
+  }
+  onActivity(paneId, cb) {
+    const entry = this.entries.get(paneId);
+    if (entry) entry.onActivityCallbacks.push(cb);
+  }
+  write(_paneId, _data) {
+  }
+  resize(_paneId, _cols, _rows) {
+  }
+  getScrollback(paneId) {
+    const entry = this.entries.get(paneId);
+    return entry ? entry.scrollback.join("") : "";
+  }
+  kill(paneId) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    entry.proc.kill();
+    this.entries.delete(paneId);
+  }
+  killAll() {
+    for (const paneId of this.entries.keys()) {
+      this.kill(paneId);
+    }
+  }
+  handleStdout(paneId, chunk) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    entry.stdoutBuffer += chunk;
+    while (true) {
+      const newline = entry.stdoutBuffer.indexOf("\n");
+      if (newline === -1) break;
+      const line = entry.stdoutBuffer.slice(0, newline).trim();
+      entry.stdoutBuffer = entry.stdoutBuffer.slice(newline + 1);
+      if (!line) continue;
+      try {
+        const message = JSON.parse(line);
+        this.handleMessage(paneId, message);
+      } catch {
+        this.emitTerminal(paneId, line + "\n");
+      }
+    }
+  }
+  handleMessage(paneId, message) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    if (typeof message.id === "number") {
+      const pending = entry.pending.get(message.id);
+      if (pending) {
+        entry.pending.delete(message.id);
+        if ("error" in message && message.error) {
+          const err = message.error;
+          pending.reject(new Error(err?.message || "ACP request failed"));
+        } else {
+          pending.resolve(message.result);
+        }
+      }
+      return;
+    }
+    if (message.method === "session/update") {
+      const params = message.params || {};
+      this.handleSessionUpdate(paneId, params);
+      return;
+    }
+  }
+  handleSessionUpdate(paneId, params) {
+    const sessionId = this.extractSessionId(params);
+    if (sessionId) {
+      this.updateMeta(paneId, { sessionId });
+    }
+    const rawUpdate = params.update || params.delta || params.event || params;
+    const updates = Array.isArray(rawUpdate) ? rawUpdate : [rawUpdate];
+    for (const update of updates) {
+      if (!update || typeof update !== "object") continue;
+      const record = update;
+      const kind = String(record.type || record.kind || "");
+      const content = this.extractText(record);
+      if (kind.includes("agent_message")) {
+        const messageId = `assistant-${this.entries.get(paneId)?.nextMessageId ?? 1}`;
+        this.emitConversation(paneId, {
+          type: "message",
+          messageId,
+          role: "assistant",
+          text: content,
+          append: true
+        });
+        if (content) {
+          this.emitTerminal(paneId, content);
+        }
+        this.setStatus(paneId, "running");
+      } else if (kind.includes("tool_call")) {
+        const toolCallId = `tool-${this.entries.get(paneId)?.nextToolId ?? 1}`;
+        this.emitConversation(paneId, {
+          type: "tool",
+          toolCallId,
+          title: String(record.title || record.name || "tool"),
+          status: kind.includes("update") ? "in_progress" : "pending",
+          text: content || void 0
+        });
+        if (content) {
+          this.emitTerminal(paneId, `
+[tool] ${content}
+`);
+        }
+      } else if (kind.includes("turn") || kind.includes("done") || kind.includes("completed")) {
+        this.setStatus(paneId, "idle");
+        this.emitConversation(paneId, { type: "status", status: "idle" });
+      }
+    }
+  }
+  extractText(record) {
+    const direct = record.text || record.delta || record.content;
+    if (typeof direct === "string") return direct;
+    if (Array.isArray(direct)) {
+      return direct.map((item) => {
+        if (typeof item === "string") return item;
+        if (item && typeof item === "object" && typeof item.text === "string") {
+          return String(item.text);
+        }
+        return "";
+      }).join("");
+    }
+    if (direct && typeof direct === "object" && typeof direct.text === "string") {
+      return String(direct.text);
+    }
+    return "";
+  }
+  request(paneId, method, params) {
+    const entry = this.entries.get(paneId);
+    if (!entry) {
+      return Promise.reject(new Error(`Missing ACP entry for ${paneId}`));
+    }
+    const id = entry.nextRequestId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    entry.proc.stdin.write(payload);
+    return new Promise((resolve, reject) => {
+      entry.pending.set(id, { resolve, reject });
+    });
+  }
+  extractSessionId(result) {
+    if (!result || typeof result !== "object") return void 0;
+    const record = result;
+    if (typeof record.sessionId === "string") return record.sessionId;
+    if (typeof record.session_id === "string") return record.session_id;
+    if (record.session && typeof record.session === "object") {
+      const nested = record.session;
+      if (typeof nested.id === "string") return nested.id;
+      if (typeof nested.sessionId === "string") return nested.sessionId;
+    }
+    return void 0;
+  }
+  emitTerminal(paneId, data) {
+    const entry = this.entries.get(paneId);
+    if (!entry || !data) return;
+    entry.scrollback.push(data);
+    entry.scrollbackBytes += data.length;
+    if (entry.scrollbackBytes > MAX_SCROLLBACK_BYTES2) {
+      let bytesToRemove = entry.scrollbackBytes - MAX_SCROLLBACK_BYTES2;
+      let removeCount = 0;
+      while (removeCount < entry.scrollback.length - 1 && bytesToRemove > 0) {
+        bytesToRemove -= entry.scrollback[removeCount].length;
+        entry.scrollbackBytes -= entry.scrollback[removeCount].length;
+        removeCount++;
+      }
+      if (removeCount > 0) entry.scrollback.splice(0, removeCount);
+    }
+    for (const cb of entry.onDataCallbacks) {
+      cb(data);
+    }
+  }
+  setStatus(paneId, status) {
+    const entry = this.entries.get(paneId);
+    if (!entry || entry.status === status) return;
+    entry.status = status;
+    for (const cb of entry.onStatusCallbacks) {
+      cb(status);
+    }
+  }
+  updateMeta(paneId, meta) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    entry.meta = { ...entry.meta, ...meta };
+    for (const cb of entry.onMetaCallbacks) {
+      cb(entry.meta);
+    }
+  }
+  emitConversation(paneId, event) {
+    const entry = this.entries.get(paneId);
+    if (!entry) return;
+    for (const cb of entry.onConversationCallbacks) {
+      cb(event);
+    }
+  }
+};
+
+// src/git/WorktreeManager.ts
+import path4 from "path";
+import fs4 from "fs";
 import { simpleGit } from "simple-git";
 var WorktreeManager = class {
   projectDir;
@@ -1087,20 +1514,49 @@ var WorktreeManager = class {
     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)) {
+    const worktreePath = path4.join(this.projectDir, ".nexus", "worktrees", paneId);
+    if (fs4.existsSync(worktreePath)) {
       await this.forceRemoveWorktree(worktreePath);
     }
     try {
       await this.git.raw(["branch", "-D", branch]);
     } catch {
     }
-    fs3.mkdirSync(path3.dirname(worktreePath), { recursive: true });
+    fs4.mkdirSync(path4.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 };
   }
+  /**
+   * Restore a worktree from a previous session.
+   * If the worktree directory still exists, re-register it.
+   * If not, recreate it from the existing branch.
+   * Returns false if the branch no longer exists (stale config).
+   */
+  async restore(paneId, branch, worktreePath) {
+    const baseBranch = await this.getCurrentBranch();
+    try {
+      await this.git.raw(["rev-parse", "--verify", branch]);
+    } catch {
+      return false;
+    }
+    if (fs4.existsSync(worktreePath)) {
+      this.worktrees.set(paneId, { path: worktreePath, branch, baseBranch });
+      return true;
+    }
+    try {
+      await this.git.raw(["worktree", "prune"]).catch(() => {
+      });
+      fs4.mkdirSync(path4.dirname(worktreePath), { recursive: true });
+      await this.git.raw(["worktree", "add", worktreePath, branch]);
+      this.worktrees.set(paneId, { path: worktreePath, branch, baseBranch });
+      return true;
+    } catch (err) {
+      console.warn(`[WorktreeManager] Failed to restore worktree for ${paneId}:`, err.message);
+      return false;
+    }
+  }
   /**
    * Remove a worktree. Branch is kept for later merge/PR.
    */
@@ -1181,6 +1637,60 @@ var WorktreeManager = class {
     }
     return diffs;
   }
+  /**
+   * Merge the worktree branch into the base branch (e.g. main).
+   * First commits any uncommitted changes in the worktree, then merges.
+   */
+  async merge(paneId) {
+    const entry = this.worktrees.get(paneId);
+    if (!entry) {
+      return { success: false, message: "Worktree not found for this pane" };
+    }
+    const wtGit = simpleGit(entry.path);
+    try {
+      const status = await wtGit.status();
+      const hasChanges = status.modified.length > 0 || status.created.length > 0 || status.deleted.length > 0 || status.staged.length > 0 || status.not_added.length > 0;
+      if (hasChanges) {
+        await wtGit.add("-A");
+        await wtGit.commit(`nexus: auto-commit before merge (${entry.branch})`);
+      }
+      const log = await wtGit.log([`${entry.baseBranch}..${entry.branch}`]);
+      if (log.total === 0) {
+        return { success: false, message: "No changes to merge" };
+      }
+      await this.git.merge([entry.branch]);
+      return {
+        success: true,
+        message: `Merged ${log.total} commit${log.total !== 1 ? "s" : ""} from ${entry.branch} into ${entry.baseBranch}`
+      };
+    } catch (err) {
+      try {
+        await this.git.merge(["--abort"]);
+      } catch {
+      }
+      return {
+        success: false,
+        message: `Merge conflict: ${err.message}`
+      };
+    }
+  }
+  /**
+   * Discard all changes: remove worktree and delete the branch.
+   */
+  async discard(paneId) {
+    const entry = this.worktrees.get(paneId);
+    if (!entry) {
+      return { success: false, message: "Worktree not found for this pane" };
+    }
+    const branch = entry.branch;
+    await this.forceRemoveWorktree(entry.path);
+    try {
+      await this.git.raw(["branch", "-D", branch]);
+    } catch {
+    }
+    this.worktrees.delete(paneId);
+    return { success: true, message: `Discarded branch ${branch}` };
+  }
   getWorktreePath(paneId) {
     return this.worktrees.get(paneId)?.path;
   }
@@ -1217,7 +1727,7 @@ var WorktreeManager = class {
       await this.git.raw(["worktree", "remove", "--force", wtPath]);
     } catch {
       try {
-        fs3.rmSync(wtPath, { recursive: true, force: true });
+        fs4.rmSync(wtPath, { recursive: true, force: true });
         await this.git.raw(["worktree", "prune"]);
       } catch {
       }
@@ -1237,7 +1747,7 @@ var WorktreeManager = class {
 };
 
 // src/git/GitService.ts
-import path4 from "path";
+import path5 from "path";
 import { simpleGit as simpleGit2 } from "simple-git";
 import { watch } from "chokidar";
 var GitService = class {
@@ -1263,11 +1773,11 @@ var GitService = class {
         this.refresh();
       }, 1e3);
     };
-    const gitDir = path4.join(this.projectDir, ".git");
+    const gitDir = path5.join(this.projectDir, ".git");
     this.gitWatcher = watch([
-      path4.join(gitDir, "index"),
-      path4.join(gitDir, "HEAD"),
-      path4.join(gitDir, "refs")
+      path5.join(gitDir, "index"),
+      path5.join(gitDir, "HEAD"),
+      path5.join(gitDir, "refs")
     ], {
       persistent: true,
       ignoreInitial: true
@@ -1281,7 +1791,7 @@ var GitService = class {
     };
     this.workWatcher = watch(this.projectDir, {
       ignored: (filePath) => {
-        const basename = path4.basename(filePath);
+        const basename = path5.basename(filePath);
         return basename === ".git" || basename === "node_modules" || basename === ".nexus" || basename === "dist";
       },
       persistent: true,
@@ -1292,10 +1802,18 @@ var GitService = class {
   }
   async refresh() {
     try {
-      const result = await this.getDiffs();
+      const result = await Promise.race([
+        this.getDiffs(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("git diff timeout")), 15e3)
+        )
+      ]);
       this.currentResult = result;
       this.notifyListeners();
-    } catch {
+    } catch (err) {
+      if (err.message === "git diff timeout") {
+        console.warn("[GitService] git diff timed out (15s), using cached result");
+      }
     }
   }
   getCurrentDiffs() {
@@ -1327,10 +1845,10 @@ var GitService = class {
     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);
+      const fullPath = path5.join(this.projectDir, file);
+      const fs11 = await import("fs");
+      if (fs11.existsSync(fullPath)) {
+        fs11.unlinkSync(fullPath);
       }
     } else {
       await this.git.checkout(["--", file]);
@@ -1471,15 +1989,19 @@ function nextPaneId() {
 var WorkspaceManager = class {
   panes = /* @__PURE__ */ new Map();
   ptyManager;
+  acpRuntime;
   configManager;
   worktreeManager;
   perPaneGitServices = /* @__PURE__ */ new Map();
   wsName = "";
   wsDescription = "";
+  // Serialize config writes to prevent race conditions when closing multiple panes
+  configWriteLock = Promise.resolve();
   // Multi-client event listener sets
   listeners = {
     onPaneAdded: /* @__PURE__ */ new Set(),
     onPaneRemoved: /* @__PURE__ */ new Set(),
+    onConversationEvent: /* @__PURE__ */ new Set(),
     onPaneStatus: /* @__PURE__ */ new Set(),
     onPaneMeta: /* @__PURE__ */ new Set(),
     onTerminalData: /* @__PURE__ */ new Set(),
@@ -1492,9 +2014,10 @@ var WorkspaceManager = class {
   constructor(configManager) {
     this.configManager = configManager;
     this.ptyManager = new PtyManager(configManager);
+    this.acpRuntime = new AcpRuntime(configManager);
     this.worktreeManager = new WorktreeManager(configManager.getProjectDir());
   }
-  init() {
+  async init() {
     const wsConfig = this.configManager.initWorkspace();
     this.wsName = wsConfig.name;
     this.wsDescription = wsConfig.description || "";
@@ -1511,8 +2034,25 @@ var WorkspaceManager = class {
       if (paneConfig.sessionId && paneConfig.agent !== "__shell__") {
         paneConfig.restore = "resume";
       }
+      if (paneConfig.isolation === "worktree" && paneConfig.branch && paneConfig.worktreePath) {
+        try {
+          const restored = await this.worktreeManager.restore(paneConfig.id, paneConfig.branch, paneConfig.worktreePath);
+          if (!restored) {
+            console.warn(`Skipping worktree pane ${paneConfig.id} (${paneConfig.name}): branch no longer exists`);
+            failCount++;
+            continue;
+          }
+        } catch (err) {
+          console.warn(`Skipping worktree pane ${paneConfig.id} (${paneConfig.name}): restore failed:`, err.message);
+          failCount++;
+          continue;
+        }
+      }
       try {
         this.spawnPane(paneConfig);
+        if (paneConfig.isolation === "worktree" && paneConfig.worktreePath) {
+          await this.startPaneGitService(paneConfig.id, paneConfig.worktreePath);
+        }
       } catch (err) {
         console.warn(`Skipping stale pane ${paneConfig.id} (${paneConfig.name}):`, err.message);
         failCount++;
@@ -1575,7 +2115,11 @@ var WorkspaceManager = class {
   }
   async closePane(paneId) {
     const pane = this.panes.get(paneId);
-    this.ptyManager.kill(paneId);
+    if (pane?.runtime === "acp") {
+      this.acpRuntime.kill(paneId);
+    } else {
+      this.ptyManager.kill(paneId);
+    }
     if (pane?.isolation === "worktree") {
       this.stopPaneGitService(paneId);
       await this.worktreeManager.remove(paneId);
@@ -1587,7 +2131,11 @@ var WorkspaceManager = class {
   restartPane(paneId, mode, sessionId) {
     const existingState = this.panes.get(paneId);
     if (!existingState) return;
-    this.ptyManager.kill(paneId);
+    if (existingState.runtime === "acp") {
+      this.acpRuntime.kill(paneId);
+    } else {
+      this.ptyManager.kill(paneId);
+    }
     const resolvedSessionId = mode === "resume" ? sessionId || existingState.sessionId || existingState.meta.sessionId : void 0;
     const config = {
       id: paneId,
@@ -1605,14 +2153,59 @@ var WorkspaceManager = class {
     this.spawnPane(config);
     this.updatePaneConfigSessionId(paneId, resolvedSessionId);
   }
+  async mergeWorktree(paneId) {
+    const pane = this.panes.get(paneId);
+    if (!pane || pane.isolation !== "worktree") {
+      return { success: false, message: "Pane is not a worktree pane" };
+    }
+    return this.worktreeManager.merge(paneId);
+  }
+  async discardWorktree(paneId) {
+    const pane = this.panes.get(paneId);
+    if (!pane || pane.isolation !== "worktree") {
+      return { success: false, message: "Pane is not a worktree pane" };
+    }
+    this.stopPaneGitService(paneId);
+    const result = await this.worktreeManager.discard(paneId);
+    if (result.success) {
+      pane.isolation = "shared";
+      pane.worktreePath = void 0;
+      pane.branch = void 0;
+      this.emit("onPaneDiff", paneId, []);
+    }
+    return result;
+  }
   writeToPane(paneId, data) {
+    const pane = this.panes.get(paneId);
+    if (!pane) return;
+    if (pane.runtime === "acp") {
+      this.acpRuntime.write(paneId, data);
+      return;
+    }
     this.ptyManager.write(paneId, data);
   }
+  sendConversationToPane(paneId, text) {
+    const pane = this.panes.get(paneId);
+    if (!pane) return Promise.resolve();
+    if (pane.runtime === "acp") {
+      return this.acpRuntime.sendPrompt(paneId, text);
+    }
+    this.ptyManager.write(paneId, text + "\r");
+    return Promise.resolve();
+  }
   resizePane(paneId, cols, rows) {
+    const pane = this.panes.get(paneId);
+    if (!pane) return;
+    if (pane.runtime === "acp") {
+      this.acpRuntime.resize(paneId, cols, rows);
+      return;
+    }
     this.ptyManager.resize(paneId, cols, rows);
   }
   getScrollback(paneId) {
-    return this.ptyManager.getScrollback(paneId);
+    const pane = this.panes.get(paneId);
+    if (!pane) return "";
+    return pane.runtime === "acp" ? this.acpRuntime.getScrollback(paneId) : this.ptyManager.getScrollback(paneId);
   }
   // ─── Event Registration (multi-client safe) ────────────────
   /**
@@ -1669,7 +2262,8 @@ var WorkspaceManager = class {
     }
   }
   spawnPane(config, cols, rows) {
-    const pid = this.ptyManager.spawn(config.id, config, cols || 80, rows || 24);
+    const runtime = this.resolveRuntime(config.agent);
+    const pid = runtime === "acp" ? this.acpRuntime.spawn(config.id, config) : this.ptyManager.spawn(config.id, config, cols || 80, rows || 24);
     const pane = {
       id: config.id,
       name: config.name,
@@ -1682,6 +2276,7 @@ var WorkspaceManager = class {
       branch: config.branch,
       worktreePath: config.worktreePath,
       sessionId: config.sessionId,
+      runtime,
       status: "running",
       pid,
       meta: {},
@@ -1689,17 +2284,18 @@ var WorkspaceManager = class {
     };
     this.panes.set(config.id, pane);
     this.emit("onPaneAdded", pane);
-    this.ptyManager.onData(config.id, (data) => {
+    const runtimeAdapter = runtime === "acp" ? this.acpRuntime : this.ptyManager;
+    runtimeAdapter.onData(config.id, (data) => {
       this.emit("onTerminalData", config.id, data);
     });
-    this.ptyManager.onStatus(config.id, (status) => {
+    runtimeAdapter.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) => {
+    runtimeAdapter.onMeta(config.id, (meta) => {
       const p = this.panes.get(config.id);
       if (p) {
         p.meta = meta;
@@ -1710,11 +2306,21 @@ var WorkspaceManager = class {
         this.emit("onPaneMeta", config.id, meta);
       }
     });
-    this.ptyManager.onActivity(config.id, (activity) => {
+    runtimeAdapter.onActivity(config.id, (activity) => {
       this.emit("onPaneActivity", config.id, activity);
     });
+    if (runtime === "acp") {
+      this.acpRuntime.onConversation(config.id, (event) => {
+        this.emit("onConversationEvent", config.id, event);
+      });
+    }
     return pane;
   }
+  resolveRuntime(agentType) {
+    if (agentType === "__shell__") return "pty";
+    const def = this.configManager.getAgentDefinition(agentType);
+    return def?.transport || "pty";
+  }
   async startPaneGitService(paneId, worktreePath) {
     const gitService = new GitService(worktreePath);
     gitService.onDiffChange((result) => {
@@ -1732,21 +2338,25 @@ var WorkspaceManager = class {
     }
   }
   persistPaneConfig(config) {
-    const wsConfig = this.configManager.loadWorkspaceConfig();
-    if (wsConfig) {
-      wsConfig.panes.push(config);
-      this.configManager.saveWorkspaceConfig(wsConfig);
-    }
+    this.serializedConfigWrite(() => {
+      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);
+    this.serializedConfigWrite(() => {
+      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 = [];
@@ -1784,24 +2394,39 @@ var WorkspaceManager = class {
     return sessions;
   }
   removePaneFromConfig(paneId) {
-    const wsConfig = this.configManager.loadWorkspaceConfig();
-    if (wsConfig) {
-      wsConfig.panes = wsConfig.panes.filter((p) => p.id !== paneId);
-      this.configManager.saveWorkspaceConfig(wsConfig);
-    }
+    this.serializedConfigWrite(() => {
+      const wsConfig = this.configManager.loadWorkspaceConfig();
+      if (wsConfig) {
+        wsConfig.panes = wsConfig.panes.filter((p) => p.id !== paneId);
+        this.configManager.saveWorkspaceConfig(wsConfig);
+      }
+    });
+  }
+  /**
+   * Serialize config file writes to prevent race conditions
+   * when multiple panes are created/closed simultaneously.
+   */
+  serializedConfigWrite(fn) {
+    this.configWriteLock = this.configWriteLock.then(() => {
+      try {
+        fn();
+      } catch (err) {
+        console.error("[WorkspaceManager] Config write failed:", err);
+      }
+    });
   }
   async shutdown() {
     this.ptyManager.killAll();
+    this.acpRuntime.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 fs5 from "fs";
+import path6 from "path";
 import yaml2 from "js-yaml";
 var AgentsYamlWriter = class {
   projectDir;
@@ -1826,8 +2451,8 @@ var AgentsYamlWriter = class {
     this.writeFile(panes);
   }
   writeFile(panes) {
-    const nexusDir = path5.join(this.projectDir, ".nexus");
-    fs4.mkdirSync(nexusDir, { recursive: true });
+    const nexusDir = path6.join(this.projectDir, ".nexus");
+    fs5.mkdirSync(nexusDir, { recursive: true });
     const visible = panes.filter((p) => p.agent !== "__shell__");
     const data = {
       updated_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1837,11 +2462,12 @@ var AgentsYamlWriter = class {
           id: p.id,
           name: p.name,
           agent: p.agent,
+          runtime: p.runtime,
           pid: p.pid,
           status: p.status,
           isolation: p.isolation || "shared",
           branch: p.branch || void 0,
-          workdir: p.workdir ? path5.resolve(basePath, p.workdir) : basePath,
+          workdir: p.workdir ? path6.resolve(basePath, p.workdir) : basePath,
           task: p.task || void 0,
           model: p.meta.model || void 0,
           context_used_pct: p.meta.contextUsedPct ?? void 0,
@@ -1851,18 +2477,19 @@ var AgentsYamlWriter = class {
         };
       })
     };
-    const filePath = path5.join(nexusDir, "agents.yaml");
-    fs4.writeFileSync(filePath, yaml2.dump(data, { lineWidth: -1 }));
+    const filePath = path6.join(nexusDir, "agents.yaml");
+    fs5.writeFileSync(filePath, yaml2.dump(data, { lineWidth: -1 }));
   }
 };
 
 // src/fs/FsWatcher.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import { watch as watch2 } from "chokidar";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
+  ".nexus",
   "dist",
   ".cache",
   ".turbo",
@@ -1889,7 +2516,7 @@ var FsWatcher = class {
     this.notifyListeners();
     this.watcher = watch2(this.projectDir, {
       ignored: (filePath) => {
-        const basename = path6.basename(filePath);
+        const basename = path7.basename(filePath);
         return IGNORED_DIRS.has(basename) || IGNORED_FILES.has(basename);
       },
       persistent: true,
@@ -1906,9 +2533,9 @@ var FsWatcher = class {
       }, 300);
     };
     const emitFileChange = (eventType, filePath) => {
-      const relativePath = path6.relative(this.projectDir, filePath);
+      const relativePath = path7.relative(this.projectDir, filePath);
       if (!relativePath || relativePath.startsWith("..")) return;
-      if (!/\.\w{1,10}$/.test(path6.basename(filePath))) return;
+      if (!/\.\w{1,10}$/.test(path7.basename(filePath))) return;
       const now = Date.now();
       const lastChange = this.recentChanges.get(relativePath);
       if (lastChange && now - lastChange < 1e3) return;
@@ -1977,14 +2604,14 @@ var FsWatcher = class {
     return parts.join("\n");
   }
   buildTree(dirPath, depth) {
-    if (depth > 8) return [];
+    if (depth > 5) return [];
     try {
-      const entries = fs5.readdirSync(dirPath, { withFileTypes: true });
+      const entries = fs6.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);
+        const fullPath = path7.join(dirPath, entry.name);
+        const relativePath = path7.relative(this.projectDir, fullPath);
         if (entry.isDirectory()) {
           nodes.push({
             name: entry.name,
@@ -2023,19 +2650,24 @@ function setupWsHandlers(socket, workspaceManager, gitService) {
     type: "workspace.state",
     state
   });
-  const SCROLLBACK_CHUNK_SIZE = 64 * 1024;
-  for (const pane of state.panes) {
-    const scrollback = workspaceManager.getScrollback(pane.id);
-    if (scrollback) {
+  const SCROLLBACK_CHUNK_SIZE = 512 * 1024;
+  const replayScrollback = async () => {
+    for (const pane of state.panes) {
+      const scrollback = workspaceManager.getScrollback(pane.id);
+      if (!scrollback) continue;
       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) {
+          if (socket.readyState !== socket.OPEN) return;
           send({ type: "terminal.output", paneId: pane.id, data: scrollback.slice(i, i + SCROLLBACK_CHUNK_SIZE) });
+          await new Promise((resolve) => setImmediate(resolve));
         }
       }
     }
-  }
+  };
+  replayScrollback().catch(() => {
+  });
   const paneDiffs = workspaceManager.getPaneDiffs();
   for (const [paneId, diffs] of paneDiffs) {
     if (diffs.length > 0) {
@@ -2048,6 +2680,9 @@ function setupWsHandlers(socket, workspaceManager, gitService) {
     onTerminalData: (paneId, data) => {
       send({ type: "terminal.output", paneId, data });
     },
+    onConversationEvent: (paneId, event) => {
+      send({ type: "conversation.event", paneId, event });
+    },
     onPaneStatus: (paneId, status) => {
       send({ type: "pane.status", paneId, status });
     },
@@ -2085,10 +2720,21 @@ function setupWsHandlers(socket, workspaceManager, gitService) {
     }
     switch (event.type) {
       case "terminal.input":
-        workspaceManager.writeToPane(event.paneId, event.data);
+        try {
+          workspaceManager.writeToPane(event.paneId, event.data);
+        } catch {
+        }
         break;
       case "terminal.resize":
-        workspaceManager.resizePane(event.paneId, event.cols, event.rows);
+        try {
+          workspaceManager.resizePane(event.paneId, event.cols, event.rows);
+        } catch {
+        }
+        break;
+      case "conversation.send":
+        workspaceManager.sendConversationToPane(event.paneId, event.text).catch((err) => {
+          console.error("conversation.send failed:", err);
+        });
         break;
       case "pane.create":
         workspaceManager.createPane(event.config).catch((err) => {
@@ -2163,6 +2809,22 @@ function setupWsHandlers(socket, workspaceManager, gitService) {
           });
         }
         break;
+      case "pane.merge":
+        workspaceManager.mergeWorktree(event.paneId).then((result) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, ...result });
+          gitService?.refresh();
+        }).catch((err) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, success: false, message: String(err) });
+        });
+        break;
+      case "pane.discard":
+        workspaceManager.discardWorktree(event.paneId).then((result) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, ...result });
+          gitService?.refresh();
+        }).catch((err) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, success: false, message: String(err) });
+        });
+        break;
       case "pane.diff.refresh":
         workspaceManager.refreshPaneDiff(event.paneId);
         break;
@@ -2193,8 +2855,8 @@ function setupWsHandlers(socket, workspaceManager, gitService) {
 }
 
 // src/deps/DependencyAnalyzer.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 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;
@@ -2215,7 +2877,7 @@ var DependencyAnalyzer = class {
     const files = this.collectFiles(this.projectDir);
     const nodes = [];
     for (const absPath of files) {
-      const relPath = path7.relative(this.projectDir, absPath);
+      const relPath = path8.relative(this.projectDir, absPath);
       const imports = this.extractImports(absPath, relPath);
       nodes.push({ id: relPath, imports });
     }
@@ -2226,18 +2888,18 @@ var DependencyAnalyzer = class {
     const files = [];
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs7.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);
+      const fullPath = path8.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);
+        const ext = path8.extname(entry.name);
         if (JS_TS_EXTENSIONS.has(ext)) {
           files.push(fullPath);
         }
@@ -2248,7 +2910,7 @@ var DependencyAnalyzer = class {
   extractImports(absPath, relPath) {
     let content;
     try {
-      content = fs6.readFileSync(absPath, "utf-8");
+      content = fs7.readFileSync(absPath, "utf-8");
     } catch {
       return [];
     }
@@ -2265,22 +2927,22 @@ var DependencyAnalyzer = class {
       }
     }
     const imports = [];
-    const fileDir = path7.dirname(absPath);
+    const fileDir = path8.dirname(absPath);
     for (const spec of specifiers) {
       const resolved = this.resolveSpecifier(fileDir, spec);
       if (resolved) {
-        const resolvedRel = path7.relative(this.projectDir, resolved);
+        const resolvedRel = path8.relative(this.projectDir, resolved);
         imports.push(resolvedRel);
       }
     }
     return imports;
   }
   resolveSpecifier(fromDir, specifier) {
-    const base = path7.resolve(fromDir, specifier);
+    const base = path8.resolve(fromDir, specifier);
     for (const ext of RESOLVE_EXTENSIONS) {
       const candidate = base + ext;
       try {
-        if (fs6.statSync(candidate).isFile()) {
+        if (fs7.statSync(candidate).isFile()) {
           return candidate;
         }
       } catch {
@@ -2291,8 +2953,8 @@ var DependencyAnalyzer = class {
 };
 
 // src/history/SessionRecorder.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import { execFile as execFile2 } from "child_process";
 var HISTORY_DIR = ".nexus/history";
 var SESSIONS_INDEX = "sessions.json";
@@ -2310,8 +2972,8 @@ var SessionRecorder = class _SessionRecorder {
   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.sessionDir = path9.join(projectDir, HISTORY_DIR, sessionId);
+    fs8.mkdirSync(this.sessionDir, { recursive: true });
     this.retentionDays = retentionDays;
     this.session = {
       id: sessionId,
@@ -2451,47 +3113,47 @@ var SessionRecorder = class _SessionRecorder {
   }
   // ─── Query API ────────────────────────────────────────────
   static listSessions(projectDir) {
-    const indexPath = path8.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
-    if (!fs7.existsSync(indexPath)) return [];
+    const indexPath = path9.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    if (!fs8.existsSync(indexPath)) return [];
     try {
-      const data = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+      const data = JSON.parse(fs8.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;
+    const sessionPath = path9.join(projectDir, HISTORY_DIR, sessionId, "session.json");
+    if (!fs8.existsSync(sessionPath)) return null;
     try {
-      return JSON.parse(fs7.readFileSync(sessionPath, "utf-8"));
+      return JSON.parse(fs8.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;
+    const turnPath = path9.join(projectDir, HISTORY_DIR, sessionId, `${turnId}.json`);
+    if (!fs8.existsSync(turnPath)) return null;
     try {
-      return JSON.parse(fs7.readFileSync(turnPath, "utf-8"));
+      return JSON.parse(fs8.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 sessionDir = path9.join(projectDir, HISTORY_DIR, sessionId);
+    if (fs8.existsSync(sessionDir)) {
+      fs8.rmSync(sessionDir, { recursive: true, force: true });
     }
-    const indexPath = path8.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
-    if (fs7.existsSync(indexPath)) {
+    const indexPath = path9.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    if (fs8.existsSync(indexPath)) {
       try {
-        let sessions = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+        let sessions = JSON.parse(fs8.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));
+          fs8.writeFileSync(indexPath, JSON.stringify(sessions, null, 2));
           return true;
         }
       } catch {
@@ -2504,14 +3166,14 @@ var SessionRecorder = class _SessionRecorder {
     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 });
+      const sessionDir = path9.join(projectDir, HISTORY_DIR, session.id);
+      if (fs8.existsSync(sessionDir)) {
+        fs8.rmSync(sessionDir, { recursive: true, force: true });
         count++;
       }
     }
-    const indexPath = path8.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
-    fs7.writeFileSync(indexPath, JSON.stringify([], null, 2));
+    const indexPath = path9.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    fs8.writeFileSync(indexPath, JSON.stringify([], null, 2));
     return count;
   }
   /**
@@ -2519,11 +3181,11 @@ var SessionRecorder = class _SessionRecorder {
    * 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;
+    const indexPath = path9.join(projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    if (!fs8.existsSync(indexPath)) return 0;
     let sessions;
     try {
-      sessions = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+      sessions = JSON.parse(fs8.readFileSync(indexPath, "utf-8"));
     } catch {
       return 0;
     }
@@ -2539,12 +3201,12 @@ var SessionRecorder = class _SessionRecorder {
     }
     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 });
+      const sessionDir = path9.join(projectDir, HISTORY_DIR, s.id);
+      if (fs8.existsSync(sessionDir)) {
+        fs8.rmSync(sessionDir, { recursive: true, force: true });
       }
     }
-    fs7.writeFileSync(indexPath, JSON.stringify(keep, null, 2));
+    fs8.writeFileSync(indexPath, JSON.stringify(keep, null, 2));
     return remove.length;
   }
   // ─── Internal ─────────────────────────────────────────────
@@ -2651,19 +3313,19 @@ var SessionRecorder = class _SessionRecorder {
     });
   }
   writeTurnFile(turn) {
-    const turnPath = path8.join(this.sessionDir, `${turn.id}.json`);
-    fs7.writeFileSync(turnPath, JSON.stringify(turn));
+    const turnPath = path9.join(this.sessionDir, `${turn.id}.json`);
+    fs8.writeFileSync(turnPath, JSON.stringify(turn));
   }
   writeSessionFile() {
-    const sessionPath = path8.join(this.sessionDir, "session.json");
-    fs7.writeFileSync(sessionPath, JSON.stringify(this.session, null, 2));
+    const sessionPath = path9.join(this.sessionDir, "session.json");
+    fs8.writeFileSync(sessionPath, JSON.stringify(this.session, null, 2));
   }
   updateSessionsIndex() {
-    const indexPath = path8.join(this.projectDir, HISTORY_DIR, SESSIONS_INDEX);
+    const indexPath = path9.join(this.projectDir, HISTORY_DIR, SESSIONS_INDEX);
     let sessions = [];
-    if (fs7.existsSync(indexPath)) {
+    if (fs8.existsSync(indexPath)) {
       try {
-        sessions = JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+        sessions = JSON.parse(fs8.readFileSync(indexPath, "utf-8"));
       } catch {
       }
     }
@@ -2677,7 +3339,7 @@ var SessionRecorder = class _SessionRecorder {
       paneCount: this.session.panes.length,
       totalDurationMs
     });
-    fs7.writeFileSync(indexPath, JSON.stringify(sessions, null, 2));
+    fs8.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)`);
@@ -2736,13 +3398,13 @@ var SessionDiscovery = class {
 };
 
 // src/index.ts
-var __dirname = path9.dirname(fileURLToPath(import.meta.url));
+var __dirname = path10.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();
+  await workspaceManager.init();
   const agentsWriter = new AgentsYamlWriter(projectDir);
   workspaceManager.onEvents({
     onPaneAdded: () => agentsWriter.update(workspaceManager.getPanes()),
@@ -2900,17 +3562,17 @@ async function startServer(port, projectDir) {
       reply.code(400);
       return { error: "Missing path parameter" };
     }
-    if (filePath.includes("..") || path9.isAbsolute(filePath)) {
+    if (filePath.includes("..") || path10.isAbsolute(filePath)) {
       reply.code(403);
       return { error: "Invalid path" };
     }
-    const fullPath = path9.resolve(projectDir, filePath);
+    const fullPath = path10.resolve(projectDir, filePath);
     if (!fullPath.startsWith(projectDir)) {
       reply.code(403);
       return { error: "Path traversal not allowed" };
     }
     try {
-      const content = fs8.readFileSync(fullPath, "utf-8");
+      const content = fs9.readFileSync(fullPath, "utf-8");
       return { content, path: filePath };
     } catch {
       reply.code(404);
@@ -2923,20 +3585,20 @@ async function startServer(port, projectDir) {
       reply.code(400);
       return { error: "Missing path parameter" };
     }
-    if (filePath.includes("..") || path9.isAbsolute(filePath)) {
+    if (filePath.includes("..") || path10.isAbsolute(filePath)) {
       reply.code(403);
       return { error: "Invalid path" };
     }
-    const fullPath = path9.resolve(projectDir, filePath);
+    const fullPath = path10.resolve(projectDir, filePath);
     if (!fullPath.startsWith(projectDir)) {
       reply.code(403);
       return { error: "Path traversal not allowed" };
     }
-    if (!fs8.existsSync(fullPath)) {
+    if (!fs9.existsSync(fullPath)) {
       reply.code(404);
       return { error: "File not found" };
     }
-    const ext = path9.extname(fullPath).toLowerCase();
+    const ext = path10.extname(fullPath).toLowerCase();
     const mimeMap = {
       ".png": "image/png",
       ".jpg": "image/jpeg",
@@ -2950,14 +3612,14 @@ async function startServer(port, projectDir) {
       ".svg": "image/svg+xml"
     };
     const mime = mimeMap[ext] || "application/octet-stream";
-    const stream = fs8.createReadStream(fullPath);
+    const stream = fs9.createReadStream(fullPath);
     reply.type(mime);
     return reply.send(stream);
   });
-  const notesPath = path9.join(projectDir, ".nexus", "notes.yaml");
+  const notesPath = path10.join(projectDir, ".nexus", "notes.yaml");
   fastify.get("/api/notes", async () => {
     try {
-      const raw = fs8.readFileSync(notesPath, "utf-8");
+      const raw = fs9.readFileSync(notesPath, "utf-8");
       const data = yaml3.load(raw);
       return { notes: data?.notes || [] };
     } catch {
@@ -2967,20 +3629,20 @@ async function startServer(port, projectDir) {
   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");
+      fs9.mkdirSync(path10.dirname(notesPath), { recursive: true });
+      fs9.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)) {
+  const webDistPath = path10.resolve(__dirname, "../../web/dist");
+  if (!fs9.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)) {
+  if (fs9.existsSync(webDistPath)) {
     await fastify.register(fastifyStatic, {
       root: webDistPath,
       prefix: "/"
@@ -3058,14 +3720,14 @@ 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"))) {
+  while (dir !== path11.dirname(dir)) {
+    if (fs10.existsSync(path11.join(dir, "pnpm-workspace.yaml"))) {
       return dir;
     }
-    if (fs9.existsSync(path10.join(dir, ".git")) || fs9.existsSync(path10.join(dir, ".nexus"))) {
+    if (fs10.existsSync(path11.join(dir, ".git")) || fs10.existsSync(path11.join(dir, ".nexus"))) {
       bestMatch = dir;
     }
-    const parent = path10.dirname(dir);
+    const parent = path11.dirname(dir);
     if (home && parent === home && dir !== startDir) break;
     dir = parent;
   }
@@ -3077,15 +3739,15 @@ function findProjectRoot(startDir) {
 }
 function resolveProjectDir(dirArg) {
   if (process.env.NEXUS_PROJECT_DIR) {
-    return path10.resolve(process.env.NEXUS_PROJECT_DIR);
+    return path11.resolve(process.env.NEXUS_PROJECT_DIR);
   }
   if (dirArg) {
-    const resolved = path10.resolve(dirArg);
-    if (!fs9.existsSync(resolved)) {
+    const resolved = path11.resolve(dirArg);
+    if (!fs10.existsSync(resolved)) {
       console.error(`Error: directory does not exist: ${resolved}`);
       process.exit(1);
     }
-    if (!fs9.statSync(resolved).isDirectory()) {
+    if (!fs10.statSync(resolved).isDirectory()) {
       console.error(`Error: not a directory: ${resolved}`);
       process.exit(1);
     }