@vibegrid/mcp 0.1.3 → 0.2.1

package/dist/index.js

@@ -56,72 +56,6 @@ var DEFAULT_WORKSPACE = {
   iconColor: "#6b7280",
   order: 0
 };
-var IPC = {
-  TERMINAL_CREATE: "terminal:create",
-  TERMINAL_WRITE: "terminal:write",
-  TERMINAL_RESIZE: "terminal:resize",
-  TERMINAL_KILL: "terminal:kill",
-  TERMINAL_DATA: "terminal:data",
-  TERMINAL_EXIT: "terminal:exit",
-  CONFIG_LOAD: "config:load",
-  CONFIG_SAVE: "config:save",
-  CONFIG_CHANGED: "config:changed",
-  SESSIONS_GET_PREVIOUS: "sessions:getPrevious",
-  SESSIONS_CLEAR: "sessions:clear",
-  SESSIONS_GET_RECENT: "sessions:getRecent",
-  DIALOG_OPEN_DIRECTORY: "dialog:openDirectory",
-  IDE_DETECT: "ide:detect",
-  IDE_OPEN: "ide:open",
-  GIT_LIST_BRANCHES: "git:listBranches",
-  GIT_LIST_REMOTE_BRANCHES: "git:listRemoteBranches",
-  GIT_CREATE_WORKTREE: "git:createWorktree",
-  GIT_REMOVE_WORKTREE: "git:removeWorktree",
-  GIT_WORKTREE_DIRTY: "git:worktreeDirty",
-  GIT_LIST_WORKTREES: "git:listWorktrees",
-  WORKTREE_CONFIRM_CLEANUP: "worktree:confirmCleanup",
-  GIT_DIFF_STAT: "git:diffStat",
-  GIT_DIFF_FULL: "git:diffFull",
-  GIT_COMMIT: "git:commit",
-  GIT_PUSH: "git:push",
-  DIALOG_OPEN_FILE: "dialog:openFile",
-  SCHEDULER_EXECUTE: "scheduler:execute",
-  SCHEDULER_MISSED: "scheduler:missed",
-  SCHEDULER_GET_LOG: "scheduler:getLog",
-  SCHEDULER_GET_NEXT_RUN: "scheduler:getNextRun",
-  WORKFLOW_EXECUTION_COMPLETE: "workflow:executionComplete",
-  WINDOW_MINIMIZE: "window:minimize",
-  WINDOW_MAXIMIZE: "window:maximize",
-  WINDOW_CLOSE: "window:close",
-  WIDGET_STATUS_UPDATE: "widget:status-update",
-  WIDGET_FOCUS_TERMINAL: "widget:focus-terminal",
-  WIDGET_HIDE: "widget:hide",
-  WIDGET_TOGGLE: "widget:toggle",
-  WIDGET_RENDERER_STATUS: "widget:renderer-status",
-  WIDGET_SET_ENABLED: "widget:set-enabled",
-  WIDGET_PERMISSION_REQUEST: "widget:permission-request",
-  WIDGET_PERMISSION_RESPONSE: "widget:permission-response",
-  WIDGET_PERMISSION_CANCELLED: "widget:permission-cancelled",
-  SHELL_CREATE: "shell:create",
-  UPDATE_DOWNLOADED: "update:downloaded",
-  UPDATE_INSTALL: "update:install",
-  TASK_IMAGE_SAVE: "task:imageSave",
-  TASK_IMAGE_DELETE: "task:imageDelete",
-  TASK_IMAGE_GET_PATH: "task:imageGetPath",
-  TASK_IMAGE_CLEANUP: "task:imageCleanup",
-  DIALOG_OPEN_IMAGE: "dialog:openImage",
-  SESSION_ARCHIVE: "session:archive",
-  SESSION_UNARCHIVE: "session:unarchive",
-  SESSION_LIST_ARCHIVED: "session:listArchived",
-  HEADLESS_CREATE: "headless:create",
-  HEADLESS_KILL: "headless:kill",
-  HEADLESS_DATA: "headless:data",
-  HEADLESS_EXIT: "headless:exit",
-  SCRIPT_EXECUTE: "script:execute",
-  WORKFLOW_RUN_SAVE: "workflowRun:save",
-  WORKFLOW_RUN_LIST: "workflowRun:list",
-  WORKFLOW_RUN_LIST_BY_TASK: "workflowRun:listByTask",
-  AGENT_DETECT_INSTALLED: "agent:detectInstalled"
-};
 
 // ../server/src/database.ts
 var CONFIG_DIR = path.join(os.homedir(), ".vibegrid");
@@ -423,6 +357,15 @@ function loadDefaults(d) {
     },
     ...map.activeWorkspace !== void 0 && {
       activeWorkspace: map.activeWorkspace
+    },
+    ...map.mainViewMode !== void 0 && {
+      mainViewMode: map.mainViewMode
+    },
+    ...map.layoutMode !== void 0 && {
+      layoutMode: map.layoutMode
+    },
+    ...map.updateChannel !== void 0 && {
+      updateChannel: map.updateChannel
     }
   };
 }
@@ -801,6 +744,50 @@ function dbUpdateWorkflow(id, updates) {
 function dbDeleteWorkflow(id) {
   getDb().prepare("DELETE FROM workflows WHERE id = ?").run(id);
 }
+function dbListWorkspaces() {
+  const rows = getDb().prepare('SELECT * FROM workspaces ORDER BY "order"').all();
+  return rows.map(rowToWorkspace);
+}
+function dbInsertWorkspace(workspace) {
+  getDb().prepare(`INSERT INTO workspaces (id, name, icon, icon_color, "order") VALUES (?, ?, ?, ?, ?)`).run(
+    workspace.id,
+    workspace.name,
+    workspace.icon ?? null,
+    workspace.iconColor ?? null,
+    workspace.order
+  );
+}
+function dbUpdateWorkspace(id, updates) {
+  const sets = [];
+  const params = [];
+  if (updates.name !== void 0) {
+    sets.push("name = ?");
+    params.push(updates.name);
+  }
+  if (updates.icon !== void 0) {
+    sets.push("icon = ?");
+    params.push(updates.icon);
+  }
+  if (updates.iconColor !== void 0) {
+    sets.push("icon_color = ?");
+    params.push(updates.iconColor);
+  }
+  if (updates.order !== void 0) {
+    sets.push('"order" = ?');
+    params.push(updates.order);
+  }
+  if (sets.length === 0) return;
+  params.push(id);
+  getDb().prepare(`UPDATE workspaces SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+}
+function dbDeleteWorkspace(id) {
+  const d = getDb();
+  d.transaction(() => {
+    d.prepare("UPDATE projects SET workspace_id = 'personal' WHERE workspace_id = ?").run(id);
+    d.prepare("UPDATE workflows SET workspace_id = 'personal' WHERE workspace_id = ?").run(id);
+    d.prepare("DELETE FROM workspaces WHERE id = ?").run(id);
+  })();
+}
 function rowToTask(r) {
   return {
     id: r.id,
@@ -854,6 +841,67 @@ function rowToWorkspace(r) {
     order: r.order
   };
 }
+function listWorkflowRuns(workflowId, limit = 20) {
+  const d = getDb();
+  const rows = d.prepare("SELECT * FROM workflow_runs WHERE workflow_id = ? ORDER BY started_at DESC LIMIT ?").all(workflowId, limit);
+  return rows.map((r) => {
+    const nodeRows = d.prepare("SELECT * FROM workflow_run_nodes WHERE run_id = ?").all(r.id);
+    return {
+      workflowId: r.workflow_id,
+      startedAt: r.started_at,
+      ...r.completed_at != null && { completedAt: r.completed_at },
+      status: r.status,
+      ...r.trigger_task_id != null && { triggerTaskId: r.trigger_task_id },
+      nodeStates: nodeRows.map((n) => ({
+        nodeId: n.node_id,
+        status: n.status,
+        ...n.started_at != null && { startedAt: n.started_at },
+        ...n.completed_at != null && { completedAt: n.completed_at },
+        ...n.session_id != null && { sessionId: n.session_id },
+        ...n.error != null && { error: n.error },
+        ...n.logs != null && { logs: n.logs },
+        ...n.task_id != null && { taskId: n.task_id },
+        ...n.agent_session_id != null && { agentSessionId: n.agent_session_id }
+      }))
+    };
+  });
+}
+function listWorkflowRunsByTask(taskId, limit = 20) {
+  const d = getDb();
+  const rows = d.prepare(
+    `
+    SELECT DISTINCT wr.*, w.name as workflow_name
+    FROM workflow_runs wr
+    LEFT JOIN workflows w ON w.id = wr.workflow_id
+    WHERE wr.trigger_task_id = ?
+       OR wr.id IN (SELECT run_id FROM workflow_run_nodes WHERE task_id = ?)
+    ORDER BY wr.started_at DESC
+    LIMIT ?
+  `
+  ).all(taskId, taskId, limit);
+  return rows.map((r) => {
+    const nodeRows = d.prepare("SELECT * FROM workflow_run_nodes WHERE run_id = ?").all(r.id);
+    return {
+      workflowId: r.workflow_id,
+      startedAt: r.started_at,
+      ...r.completed_at != null && { completedAt: r.completed_at },
+      status: r.status,
+      ...r.trigger_task_id != null && { triggerTaskId: r.trigger_task_id },
+      ...r.workflow_name != null && { workflowName: r.workflow_name },
+      nodeStates: nodeRows.map((n) => ({
+        nodeId: n.node_id,
+        status: n.status,
+        ...n.started_at != null && { startedAt: n.started_at },
+        ...n.completed_at != null && { completedAt: n.completed_at },
+        ...n.session_id != null && { sessionId: n.session_id },
+        ...n.error != null && { error: n.error },
+        ...n.logs != null && { logs: n.logs },
+        ...n.task_id != null && { taskId: n.task_id },
+        ...n.agent_session_id != null && { agentSessionId: n.agent_session_id }
+      }))
+    };
+  });
+}
 
 // ../server/src/config-manager.ts
 var DB_DIR = path2.join(os2.homedir(), ".vibegrid");
@@ -941,840 +989,99 @@ var ConfigManager = class {
 };
 var configManager = new ConfigManager();
 
-// ../server/src/pty-manager.ts
-import * as pty from "node-pty";
-import crypto2 from "crypto";
-import os3 from "os";
-import { EventEmitter } from "events";
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
-// ../server/src/git-utils.ts
-import { execFileSync } from "child_process";
-import path3 from "path";
-import fs3 from "fs";
+// src/tools/tasks.ts
 import crypto from "crypto";
-var EXEC_OPTS = {
-  encoding: "utf-8",
-  stdio: ["pipe", "pipe", "pipe"]
+import path3 from "path";
+import { z as z2 } from "zod";
+
+// src/validation.ts
+import { z } from "zod";
+var safeName = z.string().min(1, "Name must not be empty").max(200, "Name must be 200 characters or less").refine((s) => !s.includes("..") && !s.includes("/") && !s.includes("\\"), {
+  message: "Name must not contain path traversal characters (.. / \\)"
+});
+var safeId = z.string().min(1, "ID must not be empty").max(100, "ID must be 100 characters or less");
+var safeTitle = z.string().min(1, "Title must not be empty").max(500, "Title must be 500 characters or less");
+var safeDescription = z.string().max(5e3, "Description must be 5000 characters or less");
+var safeShortText = z.string().max(200, "Value must be 200 characters or less");
+var safePrompt = z.string().max(1e4, "Prompt must be 10000 characters or less");
+var safeAbsolutePath = z.string().min(1, "Path must not be empty").max(1e3, "Path must be 1000 characters or less").refine((s) => s.startsWith("/"), { message: "Path must be absolute (start with /)" });
+var safeHexColor = z.string().regex(/^#[0-9a-fA-F]{3,8}$/, "Must be a valid hex color (e.g. #6366f1)");
+var V = {
+  name: safeName,
+  id: safeId,
+  title: safeTitle,
+  description: safeDescription,
+  shortText: safeShortText,
+  prompt: safePrompt,
+  absolutePath: safeAbsolutePath,
+  hexColor: safeHexColor
 };
-function getGitBranch(projectPath) {
-  try {
-    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 3e3
-    }).trim();
-    return branch && branch !== "HEAD" ? branch : null;
-  } catch {
-    return null;
-  }
-}
-function listBranches(projectPath) {
-  try {
-    const output = execFileSync("git", ["branch", "--format=%(refname:short)"], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 5e3
-    }).trim();
-    return output ? output.split("\n").map((b) => b.trim()).filter(Boolean) : [];
-  } catch {
-    return [];
-  }
-}
-function checkoutBranch(projectPath, branch) {
-  try {
-    execFileSync("git", ["checkout", branch], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 1e4
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function createWorktree(projectPath, branch) {
-  const projectName = path3.basename(projectPath);
-  const shortId = crypto.randomUUID().slice(0, 8);
-  const baseDir = path3.join(path3.dirname(projectPath), ".vibegrid-worktrees", projectName);
-  const worktreeDir = path3.join(baseDir, `${branch}-${shortId}`);
-  fs3.mkdirSync(baseDir, { recursive: true });
-  const localBranches = listBranches(projectPath);
-  if (localBranches.includes(branch)) {
-    try {
-      execFileSync("git", ["worktree", "add", worktreeDir, branch], {
-        cwd: projectPath,
-        ...EXEC_OPTS,
-        timeout: 3e4
-      });
-    } catch {
-      const newBranch = `${branch}-worktree-${shortId}`;
-      execFileSync("git", ["worktree", "add", "-b", newBranch, worktreeDir, branch], {
-        cwd: projectPath,
-        ...EXEC_OPTS,
-        timeout: 3e4
-      });
-      return { worktreePath: worktreeDir, branch: newBranch };
-    }
-  } else {
-    execFileSync("git", ["worktree", "add", "-b", branch, worktreeDir], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 3e4
-    });
-  }
-  return { worktreePath: worktreeDir, branch };
-}
-function getGitDiffStat(cwd) {
-  try {
-    const output = execFileSync("git", ["diff", "HEAD", "--numstat"], {
-      cwd,
-      ...EXEC_OPTS,
-      timeout: 1e4
-    }).trim();
-    if (!output) return { filesChanged: 0, insertions: 0, deletions: 0 };
-    let insertions = 0;
-    let deletions = 0;
-    let filesChanged = 0;
-    for (const line of output.split("\n")) {
-      const parts = line.split("	");
-      if (parts[0] === "-") {
-        filesChanged++;
-        continue;
+
+// src/tools/tasks.ts
+var TASK_STATUSES = ["todo", "in_progress", "in_review", "done", "cancelled"];
+var AGENT_TYPES = [
+  "claude",
+  "copilot",
+  "codex",
+  "opencode",
+  "gemini"
+];
+function registerTaskTools(server) {
+  server.tool(
+    "list_tasks",
+    "List tasks, optionally filtered by project, status, assigned agent, or workspace",
+    {
+      project_name: V.name.optional().describe("Filter by project name"),
+      status: z2.enum(TASK_STATUSES).optional().describe("Filter by status"),
+      assigned_agent: z2.enum(AGENT_TYPES).optional().describe("Filter by assigned agent type"),
+      workspace_id: V.id.optional().describe("Filter by workspace ID (returns tasks from all projects in that workspace)")
+    },
+    async (args) => {
+      let tasks = dbListTasks(args.project_name, args.status);
+      if (args.workspace_id) {
+        const projects = dbListProjects();
+        const wsProjectNames = new Set(
+          projects.filter((p) => (p.workspaceId ?? "personal") === args.workspace_id).map((p) => p.name)
+        );
+        tasks = tasks.filter((t) => wsProjectNames.has(t.projectName));
       }
-      insertions += parseInt(parts[0], 10) || 0;
-      deletions += parseInt(parts[1], 10) || 0;
-      filesChanged++;
-    }
-    return { filesChanged, insertions, deletions };
-  } catch {
-    return null;
-  }
-}
-function getGitDiffFull(cwd) {
-  try {
-    const stat = getGitDiffStat(cwd);
-    if (!stat) return null;
-    const MAX_DIFF_SIZE = 500 * 1024;
-    let rawDiff = execFileSync("git", ["diff", "HEAD", "-U3"], {
-      cwd,
-      ...EXEC_OPTS,
-      timeout: 15e3,
-      maxBuffer: MAX_DIFF_SIZE * 2
-    });
-    if (rawDiff.length > MAX_DIFF_SIZE) {
-      rawDiff = rawDiff.slice(0, MAX_DIFF_SIZE) + "\n\n... diff truncated (too large) ...\n";
-    }
-    const numstatOutput = execFileSync("git", ["diff", "HEAD", "--numstat"], {
-      cwd,
-      ...EXEC_OPTS,
-      timeout: 1e4
-    }).trim();
-    const fileStats = /* @__PURE__ */ new Map();
-    if (numstatOutput) {
-      for (const line of numstatOutput.split("\n")) {
-        const parts = line.split("	");
-        if (parts.length >= 3) {
-          const ins = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
-          const del = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
-          fileStats.set(parts.slice(2).join("	"), { insertions: ins, deletions: del });
-        }
+      if (args.assigned_agent) {
+        tasks = tasks.filter((t) => t.assignedAgent === args.assigned_agent);
       }
+      return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
     }
-    const fileDiffs = [];
-    const diffSections = rawDiff.split(/^diff --git /m).filter(Boolean);
-    for (const section of diffSections) {
-      const fullSection = "diff --git " + section;
-      const plusMatch = fullSection.match(/^\+\+\+ b\/(.+)$/m);
-      const minusMatch = fullSection.match(/^--- a\/(.+)$/m);
-      const filePath = plusMatch?.[1] || minusMatch?.[1]?.replace(/^\/dev\/null$/, "") || "unknown";
-      let status = "modified";
-      if (fullSection.includes("--- /dev/null")) {
-        status = "added";
-      } else if (fullSection.includes("+++ /dev/null")) {
-        status = "deleted";
-      } else if (fullSection.includes("rename from")) {
-        status = "renamed";
+  );
+  server.tool(
+    "create_task",
+    "Create a new task in a project",
+    {
+      project_name: V.name.describe("Project name (must match existing project)"),
+      title: V.title.describe("Task title"),
+      description: V.description.optional().describe("Task description (markdown)"),
+      status: z2.enum(TASK_STATUSES).optional().describe("Task status (default: todo)"),
+      branch: V.shortText.optional().describe("Git branch for this task"),
+      use_worktree: z2.boolean().optional().describe("Create a git worktree for this task"),
+      assigned_agent: z2.enum(AGENT_TYPES).optional().describe("Assign to an agent type")
+    },
+    async (args) => {
+      const project = dbGetProject(args.project_name);
+      if (!project) {
+        return {
+          content: [{ type: "text", text: `Error: project "${args.project_name}" not found` }],
+          isError: true
+        };
       }
-      const stats = fileStats.get(filePath) || { insertions: 0, deletions: 0 };
-      fileDiffs.push({
-        filePath,
-        status,
-        insertions: stats.insertions,
-        deletions: stats.deletions,
-        diff: fullSection
-      });
-    }
-    return { stat, files: fileDiffs };
-  } catch {
-    return null;
-  }
-}
-
-// ../server/src/agent-launch.ts
-import { execFileSync as execFileSync3 } from "child_process";
-
-// ../server/src/process-utils.ts
-import { execFileSync as execFileSync2 } from "child_process";
-function getUserShellEnv() {
-  if (process.platform === "win32") return { ...process.env };
-  try {
-    const shell = process.env.SHELL || "/bin/zsh";
-    const output = execFileSync2(shell, ["-ilc", "env"], {
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const env = {};
-    for (const line of output.split("\n")) {
-      const idx = line.indexOf("=");
-      if (idx > 0) {
-        env[line.substring(0, idx)] = line.substring(idx + 1);
-      }
-    }
-    return env;
-  } catch {
-    return { ...process.env };
-  }
-}
-var resolvedEnv = getUserShellEnv();
-function getDefaultShell() {
-  if (process.platform === "win32") {
-    return process.env.COMSPEC || "powershell.exe";
-  }
-  return process.env.SHELL || "/bin/zsh";
-}
-function shellEscape(s) {
-  if (/^[a-zA-Z0-9_./:=@%+,-]+$/.test(s)) return s;
-  return "'" + s.replace(/'/g, "'\\''") + "'";
-}
-var SENSITIVE_ENV_PREFIXES = [
-  "AWS_SECRET",
-  "AWS_SESSION",
-  "GITHUB_TOKEN",
-  "GH_TOKEN",
-  "OPENAI_API",
-  "ANTHROPIC_API",
-  "GOOGLE_API",
-  "STRIPE_",
-  "DATABASE_URL",
-  "DB_PASSWORD",
-  "SECRET_",
-  "PRIVATE_KEY",
-  "NPM_TOKEN",
-  "NODE_AUTH_TOKEN"
-];
-var STRIP_ENV_KEYS = ["CLAUDECODE"];
-function getSafeEnv() {
-  const env = {};
-  for (const [key, val] of Object.entries(resolvedEnv)) {
-    if (val === void 0) continue;
-    if (SENSITIVE_ENV_PREFIXES.some((p) => key.toUpperCase().startsWith(p))) continue;
-    if (STRIP_ENV_KEYS.includes(key)) continue;
-    env[key] = val;
-  }
-  return env;
-}
-
-// ../server/src/agent-launch.ts
-function commandExists(cmd, env) {
-  try {
-    const bin = process.platform === "win32" ? "where" : "which";
-    execFileSync3(bin, [cmd], { stdio: "pipe", timeout: 3e3, env });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveAgentCommand(config, env) {
-  if (commandExists(config.command, env)) {
-    return { command: config.command, args: config.args };
-  }
-  if (config.fallbackCommand && commandExists(config.fallbackCommand, env)) {
-    return { command: config.fallbackCommand, args: config.fallbackArgs ?? [] };
-  }
-  return { command: config.command, args: config.args };
-}
-function buildAgentLaunchLine(payload, agentCommands, env) {
-  const cmdConfig = agentCommands[payload.agentType] || DEFAULT_AGENT_COMMANDS[payload.agentType];
-  const cmd = resolveAgentCommand(cmdConfig, env);
-  const effectiveArgs = payload.args !== void 0 ? payload.args : cmd.args;
-  let launchLine = [cmd.command, ...effectiveArgs.map((a) => shellEscape(a))].join(" ");
-  if (payload.resumeSessionId) {
-    switch (payload.agentType) {
-      case "claude":
-        launchLine += ` --resume ${payload.resumeSessionId}`;
-        break;
-      case "copilot":
-        launchLine += ` --resume ${payload.resumeSessionId}`;
-        break;
-      case "codex":
-        launchLine = `${cmd.command} resume ${payload.resumeSessionId}`;
-        break;
-      case "opencode":
-        launchLine += ` --session ${payload.resumeSessionId}`;
-        break;
-      case "gemini":
-        launchLine += ` --resume latest`;
-        break;
-    }
-  }
-  if (payload.initialPrompt) {
-    const escaped = shellEscape(payload.initialPrompt);
-    switch (payload.agentType) {
-      case "copilot":
-        launchLine += ` -i ${escaped}`;
-        break;
-      case "gemini":
-        launchLine += ` -i ${escaped}`;
-        break;
-      case "opencode":
-        launchLine += ` --prompt ${escaped}`;
-        break;
-      default:
-        launchLine += ` ${escaped}`;
-        break;
-    }
-  }
-  return launchLine;
-}
-
-// ../server/src/pty-manager.ts
-var PtyManager = class extends EventEmitter {
-  ptys = /* @__PURE__ */ new Map();
-  sessions = /* @__PURE__ */ new Map();
-  agentCommands = { ...DEFAULT_AGENT_COMMANDS };
-  remoteHosts = [];
-  dataBuffers = /* @__PURE__ */ new Map();
-  flushTimers = /* @__PURE__ */ new Map();
-  setRemoteHosts(hosts) {
-    this.remoteHosts = hosts;
-  }
-  setAgentCommands(overrides) {
-    this.agentCommands = { ...DEFAULT_AGENT_COMMANDS };
-    if (overrides) {
-      for (const [key, val] of Object.entries(overrides)) {
-        if (val) {
-          this.agentCommands[key] = val;
-        }
-      }
-    }
-  }
-  buildAgentLaunchLine(payload) {
-    return buildAgentLaunchLine(payload, this.agentCommands, getSafeEnv());
-  }
-  createPty(payload) {
-    const id = crypto2.randomUUID();
-    const shell = getDefaultShell();
-    const remoteHost = payload.remoteHostId ? this.remoteHosts.find((h) => h.id === payload.remoteHostId) : void 0;
-    const session = remoteHost ? this.createRemotePty(id, shell, payload, remoteHost) : this.createLocalPty(id, shell, payload);
-    this.emit("session-created", session, payload);
-    return session;
-  }
-  createLocalPty(id, shell, payload) {
-    let effectivePath = payload.projectPath;
-    let worktreePath;
-    let effectiveBranch;
-    if (payload.existingWorktreePath) {
-      effectivePath = payload.existingWorktreePath;
-      worktreePath = payload.existingWorktreePath;
-      effectiveBranch = payload.branch;
-    } else if (payload.useWorktree && payload.branch) {
-      const result = createWorktree(payload.projectPath, payload.branch);
-      effectivePath = result.worktreePath;
-      worktreePath = result.worktreePath;
-      effectiveBranch = result.branch;
-    } else if (payload.branch) {
-      const currentBranch = getGitBranch(payload.projectPath);
-      if (currentBranch !== payload.branch) {
-        checkoutBranch(payload.projectPath, payload.branch);
-      }
-      effectiveBranch = payload.branch;
-    }
-    const ptyProcess = pty.spawn(shell, ["-l"], {
-      name: "xterm-256color",
-      cols: 80,
-      rows: 24,
-      cwd: effectivePath,
-      env: getSafeEnv()
-    });
-    const launchLine = this.buildAgentLaunchLine(payload);
-    setTimeout(() => ptyProcess.write(launchLine + "\r"), 300);
-    this.setupPtyEvents(id, ptyProcess);
-    this.ptys.set(id, ptyProcess);
-    const branch = effectiveBranch || getGitBranch(effectivePath);
-    const session = {
-      id,
-      agentType: payload.agentType,
-      projectName: payload.projectName,
-      projectPath: payload.projectPath,
-      status: "running",
-      createdAt: Date.now(),
-      pid: ptyProcess.pid,
-      ...payload.displayName ? { displayName: payload.displayName } : {},
-      ...branch ? { branch } : {},
-      ...worktreePath ? { worktreePath, isWorktree: true } : {}
-    };
-    this.sessions.set(id, session);
-    return session;
-  }
-  createRemotePty(id, shell, payload, host) {
-    const ptyProcess = pty.spawn(shell, ["-l"], {
-      name: "xterm-256color",
-      cols: 80,
-      rows: 24,
-      cwd: os3.homedir(),
-      env: getSafeEnv()
-    });
-    const sshParts = ["ssh", "-t"];
-    if (host.port !== 22) sshParts.push("-p", String(host.port));
-    if (host.sshKeyPath) sshParts.push("-i", host.sshKeyPath);
-    if (host.sshOptions) {
-      const opts = host.sshOptions.split(/\s+/).filter(Boolean);
-      sshParts.push(...opts);
-    }
-    sshParts.push(`${host.user}@${host.hostname}`);
-    const agentLine = this.buildAgentLaunchLine(payload);
-    const remoteCmd = `cd ${shellEscape(payload.projectPath)} && ${agentLine}`;
-    setTimeout(() => {
-      if (this.ptys.has(id)) ptyProcess.write(sshParts.join(" ") + "\r");
-    }, 300);
-    let connected = false;
-    const fallbackTimer = setTimeout(() => {
-      if (!connected) {
-        connected = true;
-        if (this.ptys.has(id)) ptyProcess.write(remoteCmd + "\r");
-      }
-    }, 5e3);
-    const promptListener = ptyProcess.onData((data) => {
-      if (!connected && /[$#>]\s*$/.test(data)) {
-        connected = true;
-        clearTimeout(fallbackTimer);
-        setTimeout(() => {
-          if (this.ptys.has(id)) ptyProcess.write(remoteCmd + "\r");
-        }, 100);
-      }
-    });
-    this.setupPtyEvents(id, ptyProcess);
-    this.ptys.set(id, ptyProcess);
-    const cleanup = () => {
-      promptListener.dispose();
-    };
-    const checkConnected = setInterval(() => {
-      if (connected) {
-        cleanup();
-        clearInterval(checkConnected);
-      }
-    }, 200);
-    setTimeout(() => {
-      cleanup();
-      clearInterval(checkConnected);
-    }, 6e3);
-    const session = {
-      id,
-      agentType: payload.agentType,
-      projectName: payload.projectName,
-      projectPath: payload.projectPath,
-      status: "running",
-      createdAt: Date.now(),
-      pid: ptyProcess.pid,
-      remoteHostId: host.id,
-      remoteHostLabel: host.label,
-      ...payload.displayName ? { displayName: payload.displayName } : {}
-    };
-    this.sessions.set(id, session);
-    return session;
-  }
-  createShellPty(cwd) {
-    const id = crypto2.randomUUID();
-    const shell = getDefaultShell();
-    const ptyProcess = pty.spawn(shell, ["-l"], {
-      name: "xterm-256color",
-      cols: 80,
-      rows: 24,
-      cwd: cwd || os3.homedir(),
-      env: getSafeEnv()
-    });
-    this.setupPtyEvents(id, ptyProcess);
-    this.ptys.set(id, ptyProcess);
-    return { id, pid: ptyProcess.pid };
-  }
-  bufferData(id, data) {
-    const existing = this.dataBuffers.get(id);
-    this.dataBuffers.set(id, existing ? existing + data : data);
-    if (!this.flushTimers.has(id)) {
-      this.flushTimers.set(
-        id,
-        setTimeout(() => this.flushBuffer(id), 50)
-      );
-    }
-  }
-  flushBuffer(id) {
-    const data = this.dataBuffers.get(id);
-    this.dataBuffers.delete(id);
-    this.flushTimers.delete(id);
-    if (data) {
-      this.emit("client-message", IPC.TERMINAL_DATA, { id, data });
-    }
-  }
-  clearBuffer(id) {
-    const timer = this.flushTimers.get(id);
-    if (timer) clearTimeout(timer);
-    this.flushTimers.delete(id);
-    this.dataBuffers.delete(id);
-  }
-  setupPtyEvents(id, ptyProcess) {
-    ptyProcess.onData((data) => {
-      this.bufferData(id, data);
-    });
-    ptyProcess.onExit(({ exitCode }) => {
-      const pendingTimer = this.flushTimers.get(id);
-      if (pendingTimer) {
-        clearTimeout(pendingTimer);
-        this.flushBuffer(id);
-      }
-      this.clearBuffer(id);
-      this.ptys.delete(id);
-      const session = this.sessions.get(id);
-      if (session) {
-        this.emit("session-exit", session);
-        session.status = "idle";
-        if (session.worktreePath) {
-          this.emit("client-message", IPC.WORKTREE_CONFIRM_CLEANUP, {
-            id: session.id,
-            projectPath: session.projectPath,
-            worktreePath: session.worktreePath
-          });
-        }
-      }
-      this.emit("client-message", IPC.TERMINAL_EXIT, { id, exitCode });
-    });
-  }
-  writeToPty(id, data) {
-    this.ptys.get(id)?.write(data);
-  }
-  resizePty(id, cols, rows) {
-    this.ptys.get(id)?.resize(cols, rows);
-  }
-  killPty(id) {
-    const p = this.ptys.get(id);
-    const pendingTimer = this.flushTimers.get(id);
-    if (pendingTimer) {
-      clearTimeout(pendingTimer);
-      this.flushBuffer(id);
-    }
-    this.clearBuffer(id);
-    const session = this.sessions.get(id);
-    this.sessions.delete(id);
-    this.ptys.delete(id);
-    if (session) {
-      this.emit("session-exit", session);
-      if (session.worktreePath) {
-        this.emit("client-message", IPC.WORKTREE_CONFIRM_CLEANUP, {
-          id: session.id,
-          projectPath: session.projectPath,
-          worktreePath: session.worktreePath
-        });
-      }
-    }
-    if (p) {
-      setImmediate(() => {
-        try {
-          p.kill();
-        } catch (err) {
-          logger_default.warn(`[pty] kill failed for ${id} (already dead?):`, err);
-        }
-      });
-    } else {
-      this.emit("client-message", IPC.TERMINAL_EXIT, { id, exitCode: 0 });
-    }
-  }
-  killAll() {
-    for (const timer of this.flushTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.dataBuffers.clear();
-    this.flushTimers.clear();
-    for (const [id, p] of this.ptys) {
-      p.kill();
-      this.ptys.delete(id);
-    }
-    this.sessions.clear();
-  }
-  getActiveSessions() {
-    return Array.from(this.sessions.values());
-  }
-  updateSessionStatus(id, status) {
-    const session = this.sessions.get(id);
-    if (session) {
-      session.status = status;
-      this.emit("client-message", IPC.TERMINAL_DATA, { id, data: "" });
-    }
-  }
-  /**
-   * Finds the most-recently-created terminal matching cwd that:
-   * - is NOT already linked to a Claude session (no hookSessionId)
-   * - is NOT in the excludeIds set (already claimed by another session_id)
-   */
-  findUnlinkedSessionByCwd(cwd, excludeIds) {
-    const normalizedCwd = cwd.replace(/\/+$/, "");
-    let best;
-    let bestTime = 0;
-    for (const session of this.sessions.values()) {
-      if (session.hookSessionId) continue;
-      if (excludeIds.has(session.id)) continue;
-      const sessionPath = (session.worktreePath || session.projectPath).replace(/\/+$/, "");
-      if (sessionPath === normalizedCwd && session.createdAt > bestTime) {
-        best = session;
-        bestTime = session.createdAt;
-      }
-    }
-    return best;
-  }
-};
-var ptyManager = new PtyManager();
-
-// ../server/src/scheduler.ts
-import cron from "node-cron";
-import fs4 from "fs";
-import path4 from "path";
-import os4 from "os";
-import { EventEmitter as EventEmitter2 } from "events";
-var LOCK_DIR = path4.join(os4.homedir(), ".vibegrid");
-function acquireExecutionLock(workflowId) {
-  const minuteKey = Math.floor(Date.now() / 6e4);
-  const lockFile = path4.join(LOCK_DIR, `scheduler-${workflowId}-${minuteKey}.lock`);
-  try {
-    fs4.writeFileSync(lockFile, String(process.pid), { flag: "wx" });
-    cleanStaleLocks(workflowId, minuteKey);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function cleanStaleLocks(workflowId, currentKey) {
-  try {
-    const prefix = `scheduler-${workflowId}-`;
-    for (const f of fs4.readdirSync(LOCK_DIR)) {
-      if (f.startsWith(prefix) && f.endsWith(".lock")) {
-        const key = parseInt(f.slice(prefix.length, -5), 10);
-        if (!isNaN(key) && key < currentKey) {
-          fs4.unlinkSync(path4.join(LOCK_DIR, f));
-        }
-      }
-    }
-  } catch {
-  }
-}
-function getTriggerConfig(wf) {
-  const triggerNode = wf.nodes.find((n) => n.type === "trigger");
-  if (!triggerNode) return null;
-  return triggerNode.config;
-}
-var Scheduler = class extends EventEmitter2 {
-  cronJobs = /* @__PURE__ */ new Map();
-  timeouts = /* @__PURE__ */ new Map();
-  syncSchedules(workflows) {
-    logger_default.info(
-      `[scheduler] syncing ${workflows.length} workflows (active crons: ${this.cronJobs.size}, timeouts: ${this.timeouts.size})`
-    );
-    for (const [id] of this.cronJobs) {
-      const wf = workflows.find((w) => w.id === id);
-      const trigger = wf ? getTriggerConfig(wf) : null;
-      if (!wf || !wf.enabled || trigger?.triggerType !== "recurring") {
-        this.cronJobs.get(id)?.stop();
-        this.cronJobs.delete(id);
-      }
-    }
-    for (const [id] of this.timeouts) {
-      const wf = workflows.find((w) => w.id === id);
-      const trigger = wf ? getTriggerConfig(wf) : null;
-      if (!wf || !wf.enabled || trigger?.triggerType !== "once") {
-        clearTimeout(this.timeouts.get(id));
-        this.timeouts.delete(id);
-      }
-    }
-    for (const wf of workflows) {
-      if (!wf.enabled) {
-        logger_default.info(`[scheduler] skipping disabled workflow "${wf.name}"`);
-        continue;
-      }
-      const trigger = getTriggerConfig(wf);
-      if (!trigger) {
-        logger_default.info(`[scheduler] no trigger node for workflow "${wf.name}"`);
-        continue;
-      }
-      logger_default.info(`[scheduler] workflow "${wf.name}" trigger=${trigger.triggerType}`);
-      if (trigger.triggerType === "recurring" && !this.cronJobs.has(wf.id)) {
-        logger_default.info(
-          `[scheduler] registering recurring workflow "${wf.name}" cron="${trigger.cron}" enabled=${wf.enabled}`
-        );
-        if (!cron.validate(trigger.cron)) {
-          logger_default.error(
-            `[scheduler] invalid cron expression for workflow "${wf.name}": ${trigger.cron}`
-          );
-          continue;
-        }
-        try {
-          const task = cron.schedule(trigger.cron, () => this.executeWorkflow(wf.id), {
-            timezone: trigger.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone
-          });
-          this.cronJobs.set(wf.id, task);
-        } catch (err) {
-          logger_default.error(`[scheduler] failed to schedule workflow "${wf.name}":`, err);
-        }
-      }
-      if (trigger.triggerType === "once" && !this.timeouts.has(wf.id)) {
-        const runAt = new Date(trigger.runAt).getTime();
-        if (isNaN(runAt)) {
-          logger_default.error(`[scheduler] invalid runAt date for workflow "${wf.name}": ${trigger.runAt}`);
-          continue;
-        }
-        const delay = runAt - Date.now();
-        if (delay > 0) {
-          const MAX_DELAY = 24 * 60 * 60 * 1e3;
-          const safeDelay = Math.min(delay, MAX_DELAY);
-          const timer = setTimeout(() => {
-            if (safeDelay < delay) {
-              this.timeouts.delete(wf.id);
-              this.syncSchedules(configManager.loadConfig().workflows ?? []);
-            } else {
-              this.executeWorkflow(wf.id);
-            }
-          }, safeDelay);
-          this.timeouts.set(wf.id, timer);
-        }
-      }
-    }
-  }
-  executeWorkflow(workflowId) {
-    if (!acquireExecutionLock(workflowId)) {
-      logger_default.info(`[scheduler] skipping workflow ${workflowId} \u2014 already executed by another instance`);
-      this.timeouts.delete(workflowId);
-      return;
-    }
-    logger_default.info(`[scheduler] executing workflow ${workflowId}`);
-    this.emit("client-message", IPC.SCHEDULER_EXECUTE, { workflowId });
-    this.timeouts.delete(workflowId);
-  }
-  checkMissedSchedules(workflows) {
-    const missed = [];
-    for (const wf of workflows) {
-      if (!wf.enabled) continue;
-      const trigger = getTriggerConfig(wf);
-      if (trigger?.triggerType === "once") {
-        const runAt = new Date(trigger.runAt).getTime();
-        if (runAt < Date.now() && !wf.lastRunAt) {
-          missed.push({ workflow: wf, scheduledFor: trigger.runAt });
-        }
-      }
-    }
-    return missed;
-  }
-  getNextRun(workflowId, workflows) {
-    const wf = workflows.find((w) => w.id === workflowId);
-    if (!wf || !wf.enabled) return null;
-    const trigger = getTriggerConfig(wf);
-    if (!trigger) return null;
-    if (trigger.triggerType === "once") {
-      const runAt = new Date(trigger.runAt).getTime();
-      return runAt > Date.now() ? trigger.runAt : null;
-    }
-    if (trigger.triggerType === "recurring") {
-      return trigger.cron;
-    }
-    return null;
-  }
-  stopAll() {
-    for (const [, job] of this.cronJobs) job.stop();
-    for (const [, timer] of this.timeouts) clearTimeout(timer);
-    this.cronJobs.clear();
-    this.timeouts.clear();
-  }
-};
-var scheduler = new Scheduler();
-
-// src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// src/tools/tasks.ts
-import crypto3 from "crypto";
-import path5 from "path";
-import { z as z2 } from "zod";
-
-// src/validation.ts
-import { z } from "zod";
-var safeName = z.string().min(1, "Name must not be empty").max(200, "Name must be 200 characters or less").refine((s) => !s.includes("..") && !s.includes("/") && !s.includes("\\"), {
-  message: "Name must not contain path traversal characters (.. / \\)"
-});
-var safeId = z.string().min(1, "ID must not be empty").max(100, "ID must be 100 characters or less");
-var safeTitle = z.string().min(1, "Title must not be empty").max(500, "Title must be 500 characters or less");
-var safeDescription = z.string().max(5e3, "Description must be 5000 characters or less");
-var safeShortText = z.string().max(200, "Value must be 200 characters or less");
-var safePrompt = z.string().max(1e4, "Prompt must be 10000 characters or less");
-var safeAbsolutePath = z.string().min(1, "Path must not be empty").max(1e3, "Path must be 1000 characters or less").refine((s) => s.startsWith("/"), { message: "Path must be absolute (start with /)" });
-var safeHexColor = z.string().regex(/^#[0-9a-fA-F]{3,8}$/, "Must be a valid hex color (e.g. #6366f1)");
-var V = {
-  name: safeName,
-  id: safeId,
-  title: safeTitle,
-  description: safeDescription,
-  shortText: safeShortText,
-  prompt: safePrompt,
-  absolutePath: safeAbsolutePath,
-  hexColor: safeHexColor
-};
-
-// src/tools/tasks.ts
-var TASK_STATUSES = ["todo", "in_progress", "in_review", "done", "cancelled"];
-var AGENT_TYPES = [
-  "claude",
-  "copilot",
-  "codex",
-  "opencode",
-  "gemini"
-];
-function registerTaskTools(server, deps) {
-  const { configManager: configManager2 } = deps;
-  server.tool(
-    "list_tasks",
-    "List tasks, optionally filtered by project and/or status",
-    {
-      project_name: V.name.optional().describe("Filter by project name"),
-      status: z2.enum(TASK_STATUSES).optional().describe("Filter by status")
-    },
-    async (args) => {
-      const tasks = dbListTasks(args.project_name, args.status);
-      return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
-    }
-  );
-  server.tool(
-    "create_task",
-    "Create a new task in a project",
-    {
-      project_name: V.name.describe("Project name (must match existing project)"),
-      title: V.title.describe("Task title"),
-      description: V.description.optional().describe("Task description (markdown)"),
-      status: z2.enum(TASK_STATUSES).optional().describe("Task status (default: todo)"),
-      branch: V.shortText.optional().describe("Git branch for this task"),
-      use_worktree: z2.boolean().optional().describe("Create a git worktree for this task"),
-      assigned_agent: z2.enum(AGENT_TYPES).optional().describe("Assign to an agent type")
-    },
-    async (args) => {
-      const project = dbGetProject(args.project_name);
-      if (!project) {
-        return {
-          content: [{ type: "text", text: `Error: project "${args.project_name}" not found` }],
-          isError: true
-        };
-      }
-      const maxOrder = dbGetMaxTaskOrder(args.project_name);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const status = args.status ?? "todo";
-      const task = {
-        id: crypto3.randomUUID(),
-        projectName: args.project_name,
-        title: args.title,
-        description: args.description ?? "",
+      const maxOrder = dbGetMaxTaskOrder(args.project_name);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const status = args.status ?? "todo";
+      const task = {
+        id: crypto.randomUUID(),
+        projectName: args.project_name,
+        title: args.title,
+        description: args.description ?? "",
         status,
         order: maxOrder + 1,
         createdAt: now,
@@ -1785,7 +1092,6 @@ function registerTaskTools(server, deps) {
         ...(status === "done" || status === "cancelled") && { completedAt: now }
       };
       dbInsertTask(task);
-      configManager2.notifyChanged();
       return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
     }
   );
@@ -1837,7 +1143,6 @@ function registerTaskTools(server, deps) {
         if (!isDone && wasDone) updates.completedAt = void 0;
       }
       dbUpdateTask(args.id, updates);
-      configManager2.notifyChanged();
       const updated = dbGetTask(args.id);
       return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
     }
@@ -1855,7 +1160,6 @@ function registerTaskTools(server, deps) {
         };
       }
       dbDeleteTask(args.id);
-      configManager2.notifyChanged();
       return { content: [{ type: "text", text: `Deleted task: ${task.title}` }] };
     }
   );
@@ -1902,12 +1206,12 @@ function registerTaskTools(server, deps) {
         };
       }
       const cwd = args.cwd || process.cwd();
-      const normalizedCwd = path5.resolve(cwd);
+      const normalizedCwd = path3.resolve(cwd);
       const projects = dbListProjects();
       let matchedProject = null;
       let matchLen = 0;
       for (const p of projects) {
-        const normalizedPath = path5.resolve(p.path);
+        const normalizedPath = path3.resolve(p.path);
         if (normalizedCwd.startsWith(normalizedPath) && normalizedPath.length > matchLen) {
           matchedProject = p;
           matchLen = normalizedPath.length;
@@ -1935,7 +1239,7 @@ function registerTaskTools(server, deps) {
       let matchedTask = null;
       for (const t of projectTasks) {
         if (t.worktreePath) {
-          const normalizedWorktree = path5.resolve(t.worktreePath);
+          const normalizedWorktree = path3.resolve(t.worktreePath);
           if (normalizedCwd.startsWith(normalizedWorktree)) {
             matchedTask = t;
             break;
@@ -1979,12 +1283,21 @@ var AGENT_TYPES2 = [
   "opencode",
   "gemini"
 ];
-function registerProjectTools(server, deps) {
-  const { configManager: configManager2 } = deps;
-  server.tool("list_projects", "List all projects", async () => {
-    const projects = dbListProjects();
-    return { content: [{ type: "text", text: JSON.stringify(projects, null, 2) }] };
-  });
+function registerProjectTools(server) {
+  server.tool(
+    "list_projects",
+    "List all projects, optionally filtered by workspace",
+    {
+      workspace_id: V.id.optional().describe('Filter by workspace ID (e.g. "personal")')
+    },
+    async (args) => {
+      let projects = dbListProjects();
+      if (args.workspace_id) {
+        projects = projects.filter((p) => (p.workspaceId ?? "personal") === args.workspace_id);
+      }
+      return { content: [{ type: "text", text: JSON.stringify(projects, null, 2) }] };
+    }
+  );
   server.tool(
     "create_project",
     "Create a new project",
@@ -2010,7 +1323,6 @@ function registerProjectTools(server, deps) {
         ...args.icon_color && { iconColor: args.icon_color }
       };
       dbInsertProject(project);
-      configManager2.notifyChanged();
       return { content: [{ type: "text", text: JSON.stringify(project, null, 2) }] };
     }
   );
@@ -2038,7 +1350,6 @@ function registerProjectTools(server, deps) {
       if (args.icon !== void 0) updates.icon = args.icon;
       if (args.icon_color !== void 0) updates.iconColor = args.icon_color;
       dbUpdateProject(args.name, updates);
-      configManager2.notifyChanged();
       const updated = dbGetProject(args.name);
       return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
     }
@@ -2055,7 +1366,6 @@ function registerProjectTools(server, deps) {
         };
       }
       dbDeleteProject(args.name);
-      configManager2.notifyChanged();
       return { content: [{ type: "text", text: `Deleted project: ${args.name}` }] };
     }
   );
@@ -2063,6 +1373,78 @@ function registerProjectTools(server, deps) {
 
 // src/tools/sessions.ts
 import { z as z4 } from "zod";
+
+// src/ws-client.ts
+import fs3 from "fs";
+import path4 from "path";
+import os3 from "os";
+import { WebSocket } from "ws";
+var PORT_FILE = path4.join(os3.homedir(), ".vibegrid", "ws-port");
+var TIMEOUT_MS = 1e4;
+var rpcId = 0;
+function readPort() {
+  try {
+    const raw = fs3.readFileSync(PORT_FILE, "utf-8").trim();
+    const port = parseInt(raw, 10);
+    return Number.isFinite(port) && port > 0 ? port : null;
+  } catch {
+    return null;
+  }
+}
+async function rpcCall(method, params) {
+  const port = readPort();
+  if (!port) {
+    throw new Error("VibeGrid app is not running. Start VibeGrid to use session management tools.");
+  }
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`);
+    const id = ++rpcId;
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`RPC call "${method}" timed out after ${TIMEOUT_MS}ms`));
+    }, TIMEOUT_MS);
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.id !== id) return;
+        clearTimeout(timer);
+        ws.close();
+        if (msg.error) {
+          reject(new Error(msg.error.message));
+        } else {
+          resolve(msg.result);
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`Cannot connect to VibeGrid server: ${err.message}. Is the app running?`));
+    });
+  });
+}
+async function rpcNotify(method, params) {
+  const port = readPort();
+  if (!port) {
+    throw new Error("VibeGrid app is not running. Start VibeGrid to use session management tools.");
+  }
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`);
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
+      ws.close();
+      resolve();
+    });
+    ws.on("error", (err) => {
+      reject(new Error(`Cannot connect to VibeGrid server: ${err.message}. Is the app running?`));
+    });
+  });
+}
+
+// src/tools/sessions.ts
 var AGENT_TYPES3 = [
   "claude",
   "copilot",
@@ -2070,37 +1452,86 @@ var AGENT_TYPES3 = [
   "opencode",
   "gemini"
 ];
-function registerSessionTools(server, deps) {
-  const { ptyManager: ptyManager2 } = deps;
-  server.tool("list_sessions", "List all active terminal sessions", async () => {
-    const sessions = ptyManager2.getActiveSessions();
-    const summary = sessions.map((s) => ({
-      id: s.id,
-      agentType: s.agentType,
-      projectName: s.projectName,
-      status: s.status,
-      displayName: s.displayName,
-      branch: s.branch,
-      pid: s.pid
-    }));
-    return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
-  });
+function registerSessionTools(server) {
   server.tool(
-    "launch_agent",
-    "Launch an AI agent in a new terminal session",
+    "list_sessions",
+    "List all active terminal sessions. Requires the VibeGrid app to be running.",
     {
-      agent_type: z4.enum(AGENT_TYPES3).describe("Agent type to launch"),
-      project_name: V.name.describe("Project name"),
-      project_path: V.absolutePath.describe("Absolute path to project directory"),
-      prompt: V.prompt.optional().describe("Initial prompt to send to the agent"),
-      branch: V.shortText.optional().describe("Git branch to checkout"),
-      use_worktree: z4.boolean().optional().describe("Create a git worktree"),
-      display_name: V.shortText.optional().describe("Display name for the session")
+      project_name: V.name.optional().describe("Filter by project name")
     },
     async (args) => {
-      const payload = {
-        agentType: args.agent_type,
-        projectName: args.project_name,
+      try {
+        let sessions = await rpcCall("terminal:listActive");
+        if (args.project_name) {
+          sessions = sessions.filter((s) => s.projectName === args.project_name);
+        }
+        const summary = sessions.map((s) => ({
+          id: s.id,
+          agentType: s.agentType,
+          projectName: s.projectName,
+          status: s.status,
+          displayName: s.displayName,
+          branch: s.branch,
+          pid: s.pid
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_recent_sessions",
+    "List recent session history for a project. Requires the VibeGrid app to be running.",
+    {
+      project_path: V.absolutePath.optional().describe("Filter by project path")
+    },
+    async (args) => {
+      try {
+        const sessions = await rpcCall("sessions:getRecent", args.project_path);
+        return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_archived_sessions",
+    "List archived sessions. Requires the VibeGrid app to be running.",
+    async () => {
+      try {
+        const sessions = await rpcCall("session:listArchived");
+        return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "launch_agent",
+    "Launch an AI agent in a new terminal session. Requires the VibeGrid app to be running.",
+    {
+      agent_type: z4.enum(AGENT_TYPES3).describe("Agent type to launch"),
+      project_name: V.name.describe("Project name"),
+      project_path: V.absolutePath.describe("Absolute path to project directory"),
+      prompt: V.prompt.optional().describe("Initial prompt to send to the agent"),
+      branch: V.shortText.optional().describe("Git branch to checkout"),
+      use_worktree: z4.boolean().optional().describe("Create a git worktree"),
+      display_name: V.shortText.optional().describe("Display name for the session")
+    },
+    async (args) => {
+      const payload = {
+        agentType: args.agent_type,
+        projectName: args.project_name,
         projectPath: args.project_path,
         ...args.prompt && { initialPrompt: args.prompt },
         ...args.branch && { branch: args.branch },
@@ -2108,7 +1539,7 @@ function registerSessionTools(server, deps) {
         ...args.display_name && { displayName: args.display_name }
       };
       try {
-        const session = ptyManager2.createPty(payload);
+        const session = await rpcCall("terminal:create", payload);
         return {
           content: [
             {
@@ -2128,37 +1559,134 @@ function registerSessionTools(server, deps) {
           ]
         };
       } catch (err) {
-        return { content: [{ type: "text", text: `Error launching agent: ${err}` }], isError: true };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error launching agent: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "launch_headless",
+    "Launch a headless (no UI) agent session. Requires the VibeGrid app to be running.",
+    {
+      agent_type: z4.enum(AGENT_TYPES3).describe("Agent type to launch"),
+      project_name: V.name.describe("Project name"),
+      project_path: V.absolutePath.describe("Absolute path to project directory"),
+      prompt: V.prompt.optional().describe("Initial prompt to send to the agent"),
+      branch: V.shortText.optional().describe("Git branch to checkout"),
+      use_worktree: z4.boolean().optional().describe("Create a git worktree"),
+      display_name: V.shortText.optional().describe("Display name for the session")
+    },
+    async (args) => {
+      const payload = {
+        agentType: args.agent_type,
+        projectName: args.project_name,
+        projectPath: args.project_path,
+        ...args.prompt && { initialPrompt: args.prompt },
+        ...args.branch && { branch: args.branch },
+        ...args.use_worktree && { useWorktree: args.use_worktree },
+        ...args.display_name && { displayName: args.display_name }
+      };
+      try {
+        const session = await rpcCall("headless:create", payload);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  id: session.id,
+                  agentType: session.agentType,
+                  projectName: session.projectName,
+                  pid: session.pid,
+                  status: session.status
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error launching headless agent: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
       }
     }
   );
   server.tool(
     "kill_session",
-    "Kill a terminal session",
+    "Kill a terminal session. Requires the VibeGrid app to be running.",
     { id: V.id.describe("Session ID to kill") },
     async (args) => {
       try {
-        ptyManager2.killPty(args.id);
+        await rpcCall("terminal:kill", args.id);
         return { content: [{ type: "text", text: `Killed session: ${args.id}` }] };
       } catch (err) {
-        return { content: [{ type: "text", text: `Error killing session: ${err}` }], isError: true };
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error killing session: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "kill_headless",
+    "Kill a headless agent session. Requires the VibeGrid app to be running.",
+    { id: V.id.describe("Headless session ID to kill") },
+    async (args) => {
+      try {
+        await rpcCall("headless:kill", args.id);
+        return { content: [{ type: "text", text: `Killed headless session: ${args.id}` }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error killing headless session: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
       }
     }
   );
   server.tool(
     "write_to_terminal",
-    "Send input to a running terminal session",
+    "Send input to a running terminal session. Requires the VibeGrid app to be running.",
     {
       id: V.id.describe("Session ID"),
       data: z4.string().max(5e4, "Data must be 50000 characters or less").describe("Data to write (text input to send to the agent)")
     },
     async (args) => {
       try {
-        ptyManager2.writeToPty(args.id, args.data);
+        await rpcNotify("terminal:write", { id: args.id, data: args.data });
         return { content: [{ type: "text", text: `Wrote to session: ${args.id}` }] };
       } catch (err) {
         return {
-          content: [{ type: "text", text: `Error writing to terminal: ${err}` }],
+          content: [
+            {
+              type: "text",
+              text: `Error writing to terminal: ${err instanceof Error ? err.message : err}`
+            }
+          ],
           isError: true
         };
       }
@@ -2167,7 +1695,7 @@ function registerSessionTools(server, deps) {
 }
 
 // src/tools/workflows.ts
-import crypto4 from "crypto";
+import crypto2 from "crypto";
 import { z as z5 } from "zod";
 var launchAgentConfigSchema = z5.object({
   agentType: z5.enum(["claude", "copilot", "codex", "opencode", "gemini"]),
@@ -2215,7 +1743,7 @@ function buildGraphFromFlat(trigger, actions) {
   const nodes = [];
   const edges = [];
   const triggerNode = {
-    id: crypto4.randomUUID(),
+    id: crypto2.randomUUID(),
     type: "trigger",
     label: trigger.triggerType === "manual" ? "Manual Trigger" : trigger.triggerType === "once" ? "Schedule (Once)" : trigger.triggerType === "recurring" ? "Schedule (Recurring)" : trigger.triggerType === "taskCreated" ? "When Task Created" : trigger.triggerType === "taskStatusChanged" ? "When Task Status Changes" : "Trigger",
     config: trigger,
@@ -2226,7 +1754,7 @@ function buildGraphFromFlat(trigger, actions) {
   const NODE_GAP = 140;
   for (let i = 0; i < actions.length; i++) {
     const action = actions[i];
-    const nodeId = crypto4.randomUUID();
+    const nodeId = crypto2.randomUUID();
     nodes.push({
       id: nodeId,
       type: "launchAgent",
@@ -2235,7 +1763,7 @@ function buildGraphFromFlat(trigger, actions) {
       position: { x: 0, y: (i + 1) * NODE_GAP }
     });
     edges.push({
-      id: crypto4.randomUUID(),
+      id: crypto2.randomUUID(),
       source: prevId,
       target: nodeId
     });
@@ -2243,12 +1771,21 @@ function buildGraphFromFlat(trigger, actions) {
   }
   return { nodes, edges };
 }
-function registerWorkflowTools(server, deps) {
-  const { configManager: configManager2, scheduler: scheduler2 } = deps;
-  server.tool("list_workflows", "List all workflows", async () => {
-    const workflows = dbListWorkflows();
-    return { content: [{ type: "text", text: JSON.stringify(workflows, null, 2) }] };
-  });
+function registerWorkflowTools(server) {
+  server.tool(
+    "list_workflows",
+    "List all workflows, optionally filtered by workspace",
+    {
+      workspace_id: V.id.optional().describe("Filter by workspace ID")
+    },
+    async (args) => {
+      let workflows = dbListWorkflows();
+      if (args.workspace_id) {
+        workflows = workflows.filter((w) => (w.workspaceId ?? "personal") === args.workspace_id);
+      }
+      return { content: [{ type: "text", text: JSON.stringify(workflows, null, 2) }] };
+    }
+  );
   server.tool(
     "create_workflow",
     "Create a new workflow. Accepts either full nodes/edges or a convenience flat format (trigger + actions array).",
@@ -2277,7 +1814,7 @@ function registerWorkflowTools(server, deps) {
         edges = graph.edges;
       }
       const workflow = {
-        id: crypto4.randomUUID(),
+        id: crypto2.randomUUID(),
         name: args.name,
         icon: args.icon ?? "zap",
         iconColor: args.icon_color ?? "#6366f1",
@@ -2287,8 +1824,6 @@ function registerWorkflowTools(server, deps) {
         ...args.stagger_delay_ms && { staggerDelayMs: args.stagger_delay_ms }
       };
       dbInsertWorkflow(workflow);
-      scheduler2.syncSchedules(dbListWorkflows());
-      configManager2.notifyChanged();
       return { content: [{ type: "text", text: JSON.stringify(workflow, null, 2) }] };
     }
   );
@@ -2323,8 +1858,6 @@ function registerWorkflowTools(server, deps) {
       if (args.enabled !== void 0) updates.enabled = args.enabled;
       if (args.stagger_delay_ms !== void 0) updates.staggerDelayMs = args.stagger_delay_ms;
       dbUpdateWorkflow(args.id, updates);
-      scheduler2.syncSchedules(dbListWorkflows());
-      configManager2.notifyChanged();
       return {
         content: [{ type: "text", text: JSON.stringify({ ...workflow, ...updates }, null, 2) }]
       };
@@ -2344,11 +1877,308 @@ function registerWorkflowTools(server, deps) {
         };
       }
       dbDeleteWorkflow(args.id);
-      scheduler2.syncSchedules(dbListWorkflows());
-      configManager2.notifyChanged();
       return { content: [{ type: "text", text: `Deleted workflow: ${workflow.name}` }] };
     }
   );
+  server.tool(
+    "list_workflow_runs",
+    "List execution history for a workflow",
+    {
+      workflow_id: V.id.describe("Workflow ID"),
+      limit: z5.number().int().min(1).max(100).optional().describe("Max results (default: 20)")
+    },
+    async (args) => {
+      const runs = listWorkflowRuns(args.workflow_id, args.limit ?? 20);
+      return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_workflow_runs_by_task",
+    "List workflow executions triggered by a specific task",
+    {
+      task_id: V.id.describe("Task ID"),
+      limit: z5.number().int().min(1).max(100).optional().describe("Max results (default: 20)")
+    },
+    async (args) => {
+      const runs = listWorkflowRunsByTask(args.task_id, args.limit ?? 20);
+      return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_scheduler_log",
+    "Get scheduler execution log for a workflow. Requires the VibeGrid app to be running.",
+    {
+      workflow_id: V.id.optional().describe("Workflow ID (omit for all workflows)")
+    },
+    async (args) => {
+      try {
+        const log2 = await rpcCall("scheduler:getLog", args.workflow_id);
+        return { content: [{ type: "text", text: JSON.stringify(log2, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_next_scheduled_run",
+    "Get the next scheduled run time for a workflow. Requires the VibeGrid app to be running.",
+    {
+      workflow_id: V.id.describe("Workflow ID")
+    },
+    async (args) => {
+      try {
+        const nextRun = await rpcCall("scheduler:getNextRun", args.workflow_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: nextRun ? JSON.stringify({ nextRun }, null, 2) : "No scheduled run (workflow may be manual or disabled)"
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/git.ts
+import { z as z6 } from "zod";
+
+// ../server/src/git-utils.ts
+import { execFileSync } from "child_process";
+import path5 from "path";
+import fs4 from "fs";
+import crypto3 from "crypto";
+var EXEC_OPTS = {
+  encoding: "utf-8",
+  stdio: ["pipe", "pipe", "pipe"]
+};
+function getGitBranch(projectPath) {
+  try {
+    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: projectPath,
+      ...EXEC_OPTS,
+      timeout: 3e3
+    }).trim();
+    return branch && branch !== "HEAD" ? branch : null;
+  } catch {
+    return null;
+  }
+}
+function listBranches(projectPath) {
+  try {
+    const output = execFileSync("git", ["branch", "--format=%(refname:short)"], {
+      cwd: projectPath,
+      ...EXEC_OPTS,
+      timeout: 5e3
+    }).trim();
+    return output ? output.split("\n").map((b) => b.trim()).filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function listRemoteBranches(projectPath) {
+  try {
+    execFileSync("git", ["fetch", "--prune"], {
+      cwd: projectPath,
+      ...EXEC_OPTS,
+      timeout: 15e3
+    });
+    const output = execFileSync("git", ["branch", "-r", "--format=%(refname:short)"], {
+      cwd: projectPath,
+      ...EXEC_OPTS,
+      timeout: 5e3
+    }).trim();
+    return output ? output.split("\n").map((b) => b.trim().replace(/^origin\//, "")).filter((b) => b && b !== "HEAD") : [];
+  } catch {
+    return [];
+  }
+}
+function createWorktree(projectPath, branch) {
+  const projectName = path5.basename(projectPath);
+  const shortId = crypto3.randomUUID().slice(0, 8);
+  const baseDir = path5.join(path5.dirname(projectPath), ".vibegrid-worktrees", projectName);
+  const worktreeDir = path5.join(baseDir, `${branch}-${shortId}`);
+  fs4.mkdirSync(baseDir, { recursive: true });
+  const localBranches = listBranches(projectPath);
+  if (localBranches.includes(branch)) {
+    try {
+      execFileSync("git", ["worktree", "add", worktreeDir, branch], {
+        cwd: projectPath,
+        ...EXEC_OPTS,
+        timeout: 3e4
+      });
+    } catch {
+      const newBranch = `${branch}-worktree-${shortId}`;
+      execFileSync("git", ["worktree", "add", "-b", newBranch, worktreeDir, branch], {
+        cwd: projectPath,
+        ...EXEC_OPTS,
+        timeout: 3e4
+      });
+      return { worktreePath: worktreeDir, branch: newBranch };
+    }
+  } else {
+    execFileSync("git", ["worktree", "add", "-b", branch, worktreeDir], {
+      cwd: projectPath,
+      ...EXEC_OPTS,
+      timeout: 3e4
+    });
+  }
+  return { worktreePath: worktreeDir, branch };
+}
+function isWorktreeDirty(worktreePath) {
+  try {
+    const output = execFileSync("git", ["status", "--porcelain"], {
+      cwd: worktreePath,
+      ...EXEC_OPTS,
+      timeout: 5e3
+    }).trim();
+    return output.length > 0;
+  } catch {
+    return true;
+  }
+}
+function getGitDiffStat(cwd) {
+  try {
+    const output = execFileSync("git", ["diff", "HEAD", "--numstat"], {
+      cwd,
+      ...EXEC_OPTS,
+      timeout: 1e4
+    }).trim();
+    if (!output) return { filesChanged: 0, insertions: 0, deletions: 0 };
+    let insertions = 0;
+    let deletions = 0;
+    let filesChanged = 0;
+    for (const line of output.split("\n")) {
+      const parts = line.split("	");
+      if (parts[0] === "-") {
+        filesChanged++;
+        continue;
+      }
+      insertions += parseInt(parts[0], 10) || 0;
+      deletions += parseInt(parts[1], 10) || 0;
+      filesChanged++;
+    }
+    return { filesChanged, insertions, deletions };
+  } catch {
+    return null;
+  }
+}
+function getGitDiffFull(cwd) {
+  try {
+    const stat = getGitDiffStat(cwd);
+    if (!stat) return null;
+    const MAX_DIFF_SIZE = 500 * 1024;
+    let rawDiff = execFileSync("git", ["diff", "HEAD", "-U3"], {
+      cwd,
+      ...EXEC_OPTS,
+      timeout: 15e3,
+      maxBuffer: MAX_DIFF_SIZE * 2
+    });
+    if (rawDiff.length > MAX_DIFF_SIZE) {
+      rawDiff = rawDiff.slice(0, MAX_DIFF_SIZE) + "\n\n... diff truncated (too large) ...\n";
+    }
+    const numstatOutput = execFileSync("git", ["diff", "HEAD", "--numstat"], {
+      cwd,
+      ...EXEC_OPTS,
+      timeout: 1e4
+    }).trim();
+    const fileStats = /* @__PURE__ */ new Map();
+    if (numstatOutput) {
+      for (const line of numstatOutput.split("\n")) {
+        const parts = line.split("	");
+        if (parts.length >= 3) {
+          const ins = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
+          const del = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
+          fileStats.set(parts.slice(2).join("	"), { insertions: ins, deletions: del });
+        }
+      }
+    }
+    const fileDiffs = [];
+    const diffSections = rawDiff.split(/^diff --git /m).filter(Boolean);
+    for (const section of diffSections) {
+      const fullSection = "diff --git " + section;
+      const plusMatch = fullSection.match(/^\+\+\+ b\/(.+)$/m);
+      const minusMatch = fullSection.match(/^--- a\/(.+)$/m);
+      const filePath = plusMatch?.[1] || minusMatch?.[1]?.replace(/^\/dev\/null$/, "") || "unknown";
+      let status = "modified";
+      if (fullSection.includes("--- /dev/null")) {
+        status = "added";
+      } else if (fullSection.includes("+++ /dev/null")) {
+        status = "deleted";
+      } else if (fullSection.includes("rename from")) {
+        status = "renamed";
+      }
+      const stats = fileStats.get(filePath) || { insertions: 0, deletions: 0 };
+      fileDiffs.push({
+        filePath,
+        status,
+        insertions: stats.insertions,
+        deletions: stats.deletions,
+        diff: fullSection
+      });
+    }
+    return { stat, files: fileDiffs };
+  } catch {
+    return null;
+  }
+}
+function gitCommit(cwd, message, includeUnstaged) {
+  try {
+    if (includeUnstaged) {
+      execFileSync("git", ["add", "-A"], { cwd, ...EXEC_OPTS, timeout: 1e4 });
+    }
+    execFileSync("git", ["commit", "-m", message], {
+      cwd,
+      ...EXEC_OPTS,
+      timeout: 15e3
+    });
+    return { success: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, error: msg };
+  }
+}
+function gitPush(cwd) {
+  try {
+    execFileSync("git", ["push"], { cwd, ...EXEC_OPTS, timeout: 3e4 });
+    return { success: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, error: msg };
+  }
+}
+function listWorktrees(projectPath) {
+  try {
+    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
+      cwd: projectPath,
+      ...EXEC_OPTS,
+      timeout: 5e3
+    }).trim();
+    if (!output) return [];
+    const worktrees = [];
+    const blocks = output.split("\n\n");
+    for (const block of blocks) {
+      const lines = block.split("\n");
+      const wtPath = lines.find((l) => l.startsWith("worktree "))?.replace("worktree ", "");
+      const branchLine = lines.find((l) => l.startsWith("branch "));
+      const branch = branchLine?.replace("branch refs/heads/", "") || "detached";
+      if (wtPath) {
+        worktrees.push({ path: wtPath, branch, isMain: worktrees.length === 0 });
+      }
+    }
+    return worktrees;
+  } catch {
+    return [];
+  }
 }
 
 // src/tools/git.ts
@@ -2372,6 +2202,22 @@ function registerGitTools(server) {
       }
     }
   );
+  server.tool(
+    "list_remote_branches",
+    "List remote git branches for a project",
+    { project_path: V.absolutePath.describe("Absolute path to project directory") },
+    async (args) => {
+      try {
+        const remote = listRemoteBranches(args.project_path);
+        return { content: [{ type: "text", text: JSON.stringify(remote, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error listing remote branches: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "get_diff",
     "Get git diff for a project (staged and unstaged changes)",
@@ -2390,30 +2236,218 @@ function registerGitTools(server) {
       }
     }
   );
+  server.tool(
+    "get_diff_stat",
+    "Get a summary of git changes (files changed, insertions, deletions)",
+    { project_path: V.absolutePath.describe("Absolute path to project directory") },
+    async (args) => {
+      try {
+        const result = getGitDiffStat(args.project_path);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error getting diff stat: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "git_commit",
+    "Create a git commit",
+    {
+      project_path: V.absolutePath.describe("Absolute path to project directory"),
+      message: V.description.describe("Commit message"),
+      include_unstaged: z6.boolean().optional().describe("Stage all changes before committing")
+    },
+    async (args) => {
+      try {
+        const result = gitCommit(args.project_path, args.message, args.include_unstaged ?? false);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error committing: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "git_push",
+    "Push commits to the remote repository",
+    { project_path: V.absolutePath.describe("Absolute path to project directory") },
+    async (args) => {
+      try {
+        const result = gitPush(args.project_path);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error pushing: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_worktrees",
+    "List git worktrees for a project",
+    { project_path: V.absolutePath.describe("Absolute path to project directory") },
+    async (args) => {
+      try {
+        const worktrees = listWorktrees(args.project_path);
+        return { content: [{ type: "text", text: JSON.stringify(worktrees, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error listing worktrees: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "create_worktree",
+    "Create a git worktree for a branch",
+    {
+      project_path: V.absolutePath.describe("Absolute path to project directory"),
+      branch: V.shortText.describe("Branch name for the worktree")
+    },
+    async (args) => {
+      try {
+        const worktreePath = createWorktree(args.project_path, args.branch);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ path: worktreePath }, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error creating worktree: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "worktree_dirty",
+    "Check if a worktree has uncommitted changes",
+    { worktree_path: V.absolutePath.describe("Absolute path to the worktree") },
+    async (args) => {
+      try {
+        const dirty = isWorktreeDirty(args.worktree_path);
+        return { content: [{ type: "text", text: JSON.stringify({ dirty }, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error checking worktree: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
 }
 
 // src/tools/config.ts
-function registerConfigTools(server, deps) {
-  const { configManager: configManager2 } = deps;
+function registerConfigTools(server) {
   server.tool(
     "get_config",
     "Get the full VibeGrid configuration (projects, tasks, workflows, settings)",
     async () => {
-      const config = configManager2.loadConfig();
+      const config = configManager.loadConfig();
       return { content: [{ type: "text", text: JSON.stringify(config, null, 2) }] };
     }
   );
 }
 
+// src/tools/workspaces.ts
+import crypto4 from "crypto";
+import { z as z7 } from "zod";
+function registerWorkspaceTools(server) {
+  server.tool("list_workspaces", "List all workspaces", async () => {
+    const workspaces = dbListWorkspaces();
+    return { content: [{ type: "text", text: JSON.stringify(workspaces, null, 2) }] };
+  });
+  server.tool(
+    "create_workspace",
+    "Create a new workspace for organizing projects",
+    {
+      name: V.name.describe("Workspace name"),
+      icon: V.shortText.optional().describe("Lucide icon name"),
+      icon_color: V.hexColor.optional().describe("Hex color for icon")
+    },
+    async (args) => {
+      const existing = dbListWorkspaces();
+      const maxOrder = existing.reduce((max, w) => Math.max(max, w.order), 0);
+      const workspace = {
+        id: crypto4.randomUUID(),
+        name: args.name,
+        order: maxOrder + 1,
+        ...args.icon && { icon: args.icon },
+        ...args.icon_color && { iconColor: args.icon_color }
+      };
+      dbInsertWorkspace(workspace);
+      return { content: [{ type: "text", text: JSON.stringify(workspace, null, 2) }] };
+    }
+  );
+  server.tool(
+    "update_workspace",
+    "Update a workspace's properties",
+    {
+      id: V.id.describe("Workspace ID"),
+      name: V.name.optional().describe("New name"),
+      icon: V.shortText.optional().describe("Lucide icon name"),
+      icon_color: V.hexColor.optional().describe("Hex color for icon"),
+      order: z7.number().int().min(0).optional().describe("Sort order")
+    },
+    async (args) => {
+      const existing = dbListWorkspaces();
+      if (!existing.find((w) => w.id === args.id)) {
+        return {
+          content: [{ type: "text", text: `Error: workspace "${args.id}" not found` }],
+          isError: true
+        };
+      }
+      const updates = {};
+      if (args.name !== void 0) updates.name = args.name;
+      if (args.icon !== void 0) updates.icon = args.icon;
+      if (args.icon_color !== void 0) updates.iconColor = args.icon_color;
+      if (args.order !== void 0) updates.order = args.order;
+      dbUpdateWorkspace(args.id, updates);
+      const updated = dbListWorkspaces().find((w) => w.id === args.id);
+      return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
+    }
+  );
+  server.tool(
+    "delete_workspace",
+    "Delete a workspace",
+    { id: V.id.describe("Workspace ID") },
+    async (args) => {
+      if (args.id === "personal") {
+        return {
+          content: [{ type: "text", text: "Error: cannot delete the default workspace" }],
+          isError: true
+        };
+      }
+      const existing = dbListWorkspaces();
+      const workspace = existing.find((w) => w.id === args.id);
+      if (!workspace) {
+        return {
+          content: [{ type: "text", text: `Error: workspace "${args.id}" not found` }],
+          isError: true
+        };
+      }
+      dbDeleteWorkspace(args.id);
+      return { content: [{ type: "text", text: `Deleted workspace: ${workspace.name}` }] };
+    }
+  );
+}
+
 // src/server.ts
-function createMcpServer(deps, version) {
+function createMcpServer(version) {
   const server = new McpServer({ name: "vibegrid", version }, { capabilities: { tools: {} } });
   registerGitTools(server);
-  registerConfigTools(server, deps);
-  registerProjectTools(server, deps);
-  registerTaskTools(server, deps);
-  registerSessionTools(server, deps);
-  registerWorkflowTools(server, deps);
+  registerConfigTools(server);
+  registerProjectTools(server);
+  registerTaskTools(server);
+  registerSessionTools(server);
+  registerWorkflowTools(server);
+  registerWorkspaceTools(server);
   return server;
 }
 
@@ -2426,19 +2460,11 @@ console.warn = (...args) => _origError("[mcp:warn]", ...args);
 console.error = (...args) => _origError("[mcp:error]", ...args);
 async function main() {
   configManager.init();
-  const config = configManager.loadConfig();
-  if (config.agentCommands) {
-    ptyManager.setAgentCommands(config.agentCommands);
-  }
-  ptyManager.setRemoteHosts(config.remoteHosts ?? []);
-  scheduler.syncSchedules(config.workflows ?? []);
-  const version = true ? "0.1.3" : createRequire(import.meta.url)("../package.json").version;
-  const server = createMcpServer({ configManager, ptyManager, scheduler }, version);
+  const version = true ? "0.2.1" : createRequire(import.meta.url)("../package.json").version;
+  const server = createMcpServer(version);
   const transport = new StdioServerTransport();
   await server.connect(transport);
   transport.onclose = () => {
-    scheduler.stopAll();
-    ptyManager.killAll();
     configManager.close();
     process.exit(0);
   };