@vibegrid/mcp 0.1.1

package/dist/index.js

@@ -0,0 +1,2399 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../server/src/config-manager.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+
+// ../shared/src/agent-defaults.ts
+var DEFAULT_AGENT_COMMANDS = {
+  claude: {
+    command: "claude",
+    args: [],
+    headlessArgs: ["--dangerously-skip-permissions"]
+  },
+  copilot: {
+    command: "copilot",
+    args: [],
+    headlessArgs: ["--allow-all"]
+  },
+  codex: {
+    command: "codex",
+    args: [],
+    headlessArgs: ["-a", "never"]
+  },
+  opencode: { command: "opencode", args: [] },
+  gemini: {
+    command: "gemini",
+    args: [],
+    headlessArgs: ["-y"]
+  }
+};
+
+// ../server/src/database.ts
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+// ../server/src/logger.ts
+import pino from "pino";
+var log = pino({
+  level: process.env.VITEST ? "silent" : "info",
+  transport: process.env.NODE_ENV !== "production" ? { target: "pino/file", options: { destination: 2 } } : void 0
+});
+var logger_default = log;
+
+// ../shared/src/types.ts
+var DEFAULT_WORKSPACE = {
+  id: "personal",
+  name: "Personal",
+  icon: "User",
+  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");
+var DB_PATH = path.join(CONFIG_DIR, "vibegrid.db");
+var db = null;
+function getDb() {
+  if (!db) throw new Error("Database not initialized. Call initDatabase() first.");
+  return db;
+}
+function initDatabase() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  try {
+    db = new Database(DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    createSchema();
+  } catch (err) {
+    logger_default.error("[database] Failed to open database:", err);
+    const message = err instanceof Error ? err.message : String(err);
+    const isCorrupt = /corrupt|notadb|malformed|not a database|file is not a database/i.test(
+      message
+    );
+    if (isCorrupt) {
+      logger_default.warn("[database] Database appears corrupt, attempting recovery...");
+      recoverCorruptDatabase();
+    } else {
+      throw err;
+    }
+  }
+}
+function recoverCorruptDatabase() {
+  try {
+    db?.close();
+  } catch {
+  }
+  db = null;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${DB_PATH}.corrupt-${timestamp}`;
+  try {
+    if (fs.existsSync(DB_PATH)) {
+      fs.copyFileSync(DB_PATH, backupPath);
+      logger_default.info(`[database] Backed up corrupt database to ${backupPath}`);
+    }
+    for (const suffix of ["", "-wal", "-shm"]) {
+      const file = DB_PATH + suffix;
+      if (fs.existsSync(file)) fs.unlinkSync(file);
+    }
+  } catch (backupErr) {
+    logger_default.error("[database] Failed to back up corrupt database:", backupErr);
+  }
+  try {
+    db = new Database(DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    createSchema();
+    logger_default.info("[database] Successfully created fresh database after corruption recovery");
+  } catch (freshErr) {
+    logger_default.error("[database] Failed to create fresh database after corruption:", freshErr);
+    throw freshErr;
+  }
+  logger_default.warn(`[database] Database was corrupted and has been reset. Backup saved to: ${backupPath}`);
+}
+function closeDatabase() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+function createSchema() {
+  const d = getDb();
+  const cols = d.prepare("PRAGMA table_info(workflows)").all();
+  if (cols.some((c) => c.name === "actions")) {
+    d.exec("ALTER TABLE workflows RENAME TO workflows_backup_old_format");
+    logger_default.warn("[database] migrated old-format workflows table to workflows_backup_old_format");
+  }
+  d.exec(`
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS defaults (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      name TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      preferred_agents TEXT NOT NULL DEFAULT '[]',
+      icon TEXT,
+      icon_color TEXT,
+      host_ids TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      icon TEXT NOT NULL,
+      icon_color TEXT NOT NULL,
+      nodes TEXT NOT NULL DEFAULT '[]',
+      edges TEXT NOT NULL DEFAULT '[]',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at TEXT,
+      last_run_status TEXT,
+      stagger_delay_ms INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_commands (
+      agent_type TEXT PRIMARY KEY,
+      command TEXT NOT NULL,
+      args TEXT NOT NULL DEFAULT '[]',
+      fallback_command TEXT,
+      fallback_args TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS remote_hosts (
+      id TEXT PRIMARY KEY,
+      label TEXT NOT NULL,
+      hostname TEXT NOT NULL,
+      user TEXT NOT NULL,
+      port INTEGER NOT NULL DEFAULT 22,
+      ssh_key_path TEXT,
+      ssh_options TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      project_name TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'todo',
+      "order" INTEGER NOT NULL DEFAULT 0,
+      assigned_session_id TEXT,
+      assigned_agent TEXT,
+      agent_session_id TEXT,
+      branch TEXT,
+      use_worktree INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      completed_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent_type TEXT NOT NULL,
+      project_name TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      status TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      pid INTEGER NOT NULL,
+      display_name TEXT,
+      branch TEXT,
+      worktree_path TEXT,
+      is_worktree INTEGER DEFAULT 0,
+      remote_host_id TEXT,
+      remote_host_label TEXT,
+      hook_session_id TEXT,
+      status_source TEXT,
+      saved_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS schedule_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      workflow_id TEXT NOT NULL,
+      workflow_name TEXT NOT NULL,
+      executed_at TEXT NOT NULL,
+      status TEXT NOT NULL,
+      sessions_launched INTEGER NOT NULL DEFAULT 0,
+      error TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_schedule_log_workflow_id ON schedule_log(workflow_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_name, status);
+
+    CREATE TABLE IF NOT EXISTS archived_sessions (
+      id TEXT PRIMARY KEY,
+      agent_type TEXT NOT NULL,
+      project_name TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      display_name TEXT,
+      branch TEXT,
+      agent_session_id TEXT,
+      archived_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      icon TEXT,
+      icon_color TEXT,
+      "order" INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      workflow_id TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      completed_at TEXT,
+      status TEXT NOT NULL DEFAULT 'running',
+      trigger_task_id TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS workflow_run_nodes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      started_at TEXT,
+      completed_at TEXT,
+      session_id TEXT,
+      error TEXT,
+      logs TEXT,
+      task_id TEXT,
+      agent_session_id TEXT,
+      FOREIGN KEY (run_id) REFERENCES workflow_runs(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow_id);
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_task ON workflow_runs(trigger_task_id);
+    CREATE INDEX IF NOT EXISTS idx_workflow_run_nodes_run ON workflow_run_nodes(run_id);
+    CREATE INDEX IF NOT EXISTS idx_workflow_run_nodes_task ON workflow_run_nodes(task_id);
+  `);
+  migrateSchema(d);
+}
+function migrateSchema(d) {
+  const row = d.prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'").get();
+  const version = row ? parseInt(row.value, 10) : 0;
+  if (version < 1) {
+    d.transaction(() => {
+      const projectCols = d.prepare("PRAGMA table_info(projects)").all();
+      if (!projectCols.some((c) => c.name === "workspace_id")) {
+        d.exec("ALTER TABLE projects ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'personal'");
+      }
+      const workflowCols = d.prepare("PRAGMA table_info(workflows)").all();
+      if (!workflowCols.some((c) => c.name === "workspace_id")) {
+        d.exec("ALTER TABLE workflows ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'personal'");
+      }
+      d.prepare(
+        `INSERT OR IGNORE INTO workspaces (id, name, icon, icon_color, "order") VALUES (?, ?, ?, ?, ?)`
+      ).run(
+        DEFAULT_WORKSPACE.id,
+        DEFAULT_WORKSPACE.name,
+        DEFAULT_WORKSPACE.icon ?? null,
+        DEFAULT_WORKSPACE.iconColor ?? null,
+        DEFAULT_WORKSPACE.order
+      );
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '1')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 1 (workspaces)");
+  }
+}
+function loadConfig() {
+  const d = getDb();
+  const defaults = loadDefaults(d);
+  const projects = loadProjects(d);
+  const agentCommands = loadAgentCommands(d);
+  const workflows = loadWorkflows(d);
+  const remoteHosts = loadRemoteHosts(d);
+  const tasks = loadTasks(d);
+  const workspaces = loadWorkspaces(d);
+  return {
+    version: 1,
+    defaults,
+    projects,
+    agentCommands: Object.keys(agentCommands).length > 0 ? agentCommands : { ...DEFAULT_AGENT_COMMANDS },
+    workflows,
+    remoteHosts,
+    tasks,
+    workspaces
+  };
+}
+function loadDefaults(d) {
+  const rows = d.prepare("SELECT key, value FROM defaults").all();
+  const map = {};
+  for (const row of rows) {
+    map[row.key] = JSON.parse(row.value);
+  }
+  return {
+    shell: map.shell ?? (process.platform === "win32" ? process.env.COMSPEC || "powershell.exe" : process.env.SHELL || "/bin/zsh"),
+    fontSize: map.fontSize ?? 13,
+    theme: map.theme ?? "dark",
+    ...map.rowHeight !== void 0 && { rowHeight: map.rowHeight },
+    ...map.defaultAgent !== void 0 && { defaultAgent: map.defaultAgent },
+    ...map.notifications !== void 0 && {
+      notifications: map.notifications
+    },
+    ...map.hasSeenOnboarding !== void 0 && {
+      hasSeenOnboarding: map.hasSeenOnboarding
+    },
+    ...map.reopenSessions !== void 0 && { reopenSessions: map.reopenSessions },
+    ...map.widgetEnabled !== void 0 && { widgetEnabled: map.widgetEnabled },
+    ...map.taskViewMode !== void 0 && {
+      taskViewMode: map.taskViewMode
+    },
+    ...map.activeWorkspace !== void 0 && {
+      activeWorkspace: map.activeWorkspace
+    }
+  };
+}
+function loadProjects(d) {
+  const rows = d.prepare("SELECT * FROM projects").all();
+  return rows.map(rowToProject);
+}
+function loadWorkflows(d) {
+  const rows = d.prepare("SELECT * FROM workflows").all();
+  return rows.map(rowToWorkflow);
+}
+function loadAgentCommands(d) {
+  const rows = d.prepare("SELECT * FROM agent_commands").all();
+  const result = {};
+  for (const r of rows) {
+    result[r.agent_type] = {
+      command: r.command,
+      args: JSON.parse(r.args),
+      ...r.fallback_command != null && { fallbackCommand: r.fallback_command },
+      ...r.fallback_args != null && { fallbackArgs: JSON.parse(r.fallback_args) }
+    };
+  }
+  return result;
+}
+function loadRemoteHosts(d) {
+  const rows = d.prepare("SELECT * FROM remote_hosts").all();
+  return rows.map((r) => ({
+    id: r.id,
+    label: r.label,
+    hostname: r.hostname,
+    user: r.user,
+    port: r.port,
+    ...r.ssh_key_path != null && { sshKeyPath: r.ssh_key_path },
+    ...r.ssh_options != null && { sshOptions: r.ssh_options }
+  }));
+}
+function loadTasks(d) {
+  const rows = d.prepare('SELECT * FROM tasks ORDER BY "order"').all();
+  return rows.map(rowToTask);
+}
+function loadWorkspaces(d) {
+  const rows = d.prepare('SELECT * FROM workspaces ORDER BY "order"').all();
+  return rows.map(rowToWorkspace);
+}
+function saveConfig(config) {
+  const d = getDb();
+  const run = d.transaction(() => {
+    d.prepare("DELETE FROM defaults").run();
+    const insertDefault = d.prepare("INSERT INTO defaults (key, value) VALUES (?, ?)");
+    for (const [key, value] of Object.entries(config.defaults)) {
+      if (value !== void 0) {
+        insertDefault.run(key, JSON.stringify(value));
+      }
+    }
+    d.prepare("DELETE FROM projects").run();
+    const insertProject = d.prepare(
+      "INSERT INTO projects (name, path, preferred_agents, icon, icon_color, host_ids, workspace_id) VALUES (?, ?, ?, ?, ?, ?, ?)"
+    );
+    for (const p of config.projects) {
+      insertProject.run(
+        p.name,
+        p.path,
+        JSON.stringify(p.preferredAgents),
+        p.icon ?? null,
+        p.iconColor ?? null,
+        p.hostIds ? JSON.stringify(p.hostIds) : null,
+        p.workspaceId ?? "personal"
+      );
+    }
+    d.prepare("DELETE FROM workflows").run();
+    const insertWorkflow = d.prepare(
+      `INSERT INTO workflows (id, name, icon, icon_color, nodes, edges, enabled, last_run_at, last_run_status, stagger_delay_ms, workspace_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    for (const w of config.workflows ?? []) {
+      insertWorkflow.run(
+        w.id,
+        w.name,
+        w.icon,
+        w.iconColor,
+        JSON.stringify(w.nodes),
+        JSON.stringify(w.edges),
+        w.enabled ? 1 : 0,
+        w.lastRunAt ?? null,
+        w.lastRunStatus ?? null,
+        w.staggerDelayMs ?? null,
+        w.workspaceId ?? "personal"
+      );
+    }
+    d.prepare("DELETE FROM agent_commands").run();
+    const insertAgent = d.prepare(
+      "INSERT INTO agent_commands (agent_type, command, args, fallback_command, fallback_args) VALUES (?, ?, ?, ?, ?)"
+    );
+    if (config.agentCommands) {
+      for (const [agentType, cmd] of Object.entries(config.agentCommands)) {
+        if (cmd) {
+          insertAgent.run(
+            agentType,
+            cmd.command,
+            JSON.stringify(cmd.args),
+            cmd.fallbackCommand ?? null,
+            cmd.fallbackArgs ? JSON.stringify(cmd.fallbackArgs) : null
+          );
+        }
+      }
+    }
+    d.prepare("DELETE FROM remote_hosts").run();
+    const insertHost = d.prepare(
+      "INSERT INTO remote_hosts (id, label, hostname, user, port, ssh_key_path, ssh_options) VALUES (?, ?, ?, ?, ?, ?, ?)"
+    );
+    for (const h of config.remoteHosts ?? []) {
+      insertHost.run(
+        h.id,
+        h.label,
+        h.hostname,
+        h.user,
+        h.port,
+        h.sshKeyPath ?? null,
+        h.sshOptions ?? null
+      );
+    }
+    d.prepare("DELETE FROM tasks").run();
+    const insertTask = d.prepare(
+      `INSERT INTO tasks (id, project_name, title, description, status, "order", assigned_session_id, assigned_agent, agent_session_id, branch, use_worktree, created_at, updated_at, completed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    for (const t of config.tasks ?? []) {
+      insertTask.run(
+        t.id,
+        t.projectName,
+        t.title,
+        t.description,
+        t.status,
+        t.order,
+        t.assignedSessionId ?? null,
+        t.assignedAgent ?? null,
+        t.agentSessionId ?? null,
+        t.branch ?? null,
+        t.useWorktree ? 1 : 0,
+        t.createdAt,
+        t.updatedAt,
+        t.completedAt ?? null
+      );
+    }
+    d.prepare("DELETE FROM workspaces").run();
+    const insertWorkspace = d.prepare(
+      `INSERT INTO workspaces (id, name, icon, icon_color, "order") VALUES (?, ?, ?, ?, ?)`
+    );
+    for (const ws of config.workspaces ?? [DEFAULT_WORKSPACE]) {
+      insertWorkspace.run(ws.id, ws.name, ws.icon ?? null, ws.iconColor ?? null, ws.order);
+    }
+  });
+  run();
+}
+function dbListTasks(projectName, status) {
+  const d = getDb();
+  let sql = "SELECT * FROM tasks";
+  const params = [];
+  const clauses = [];
+  if (projectName) {
+    clauses.push("project_name = ?");
+    params.push(projectName);
+  }
+  if (status) {
+    clauses.push("status = ?");
+    params.push(status);
+  }
+  if (clauses.length) sql += " WHERE " + clauses.join(" AND ");
+  sql += ' ORDER BY "order"';
+  const rows = d.prepare(sql).all(...params);
+  return rows.map(rowToTask);
+}
+function dbGetTask(id) {
+  const row = getDb().prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+  return row ? rowToTask(row) : null;
+}
+function dbInsertTask(task) {
+  getDb().prepare(
+    `INSERT INTO tasks (id, project_name, title, description, status, "order", assigned_session_id, assigned_agent, agent_session_id, branch, use_worktree, created_at, updated_at, completed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    task.id,
+    task.projectName,
+    task.title,
+    task.description,
+    task.status,
+    task.order,
+    task.assignedSessionId ?? null,
+    task.assignedAgent ?? null,
+    task.agentSessionId ?? null,
+    task.branch ?? null,
+    task.useWorktree ? 1 : 0,
+    task.createdAt,
+    task.updatedAt,
+    task.completedAt ?? null
+  );
+}
+function dbUpdateTask(id, updates) {
+  const sets = [];
+  const params = [];
+  if (updates.title !== void 0) {
+    sets.push("title = ?");
+    params.push(updates.title);
+  }
+  if (updates.description !== void 0) {
+    sets.push("description = ?");
+    params.push(updates.description);
+  }
+  if (updates.status !== void 0) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.order !== void 0) {
+    sets.push('"order" = ?');
+    params.push(updates.order);
+  }
+  if (updates.branch !== void 0) {
+    sets.push("branch = ?");
+    params.push(updates.branch);
+  }
+  if (updates.useWorktree !== void 0) {
+    sets.push("use_worktree = ?");
+    params.push(updates.useWorktree ? 1 : 0);
+  }
+  if (updates.assignedAgent !== void 0) {
+    sets.push("assigned_agent = ?");
+    params.push(updates.assignedAgent);
+  }
+  if (updates.assignedSessionId !== void 0) {
+    sets.push("assigned_session_id = ?");
+    params.push(updates.assignedSessionId);
+  }
+  if (updates.agentSessionId !== void 0) {
+    sets.push("agent_session_id = ?");
+    params.push(updates.agentSessionId);
+  }
+  if (updates.updatedAt !== void 0) {
+    sets.push("updated_at = ?");
+    params.push(updates.updatedAt);
+  }
+  if ("completedAt" in updates) {
+    sets.push("completed_at = ?");
+    params.push(updates.completedAt ?? null);
+  }
+  if (sets.length === 0) return;
+  params.push(id);
+  getDb().prepare(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+}
+function dbDeleteTask(id) {
+  getDb().prepare("DELETE FROM tasks WHERE id = ?").run(id);
+}
+function dbGetMaxTaskOrder(projectName) {
+  const row = getDb().prepare('SELECT MAX("order") as m FROM tasks WHERE project_name = ?').get(projectName);
+  return row.m ?? -1;
+}
+function dbListProjects() {
+  const rows = getDb().prepare("SELECT * FROM projects").all();
+  return rows.map(rowToProject);
+}
+function dbGetProject(name) {
+  const row = getDb().prepare("SELECT * FROM projects WHERE name = ?").get(name);
+  return row ? rowToProject(row) : null;
+}
+function dbInsertProject(project) {
+  getDb().prepare(
+    "INSERT INTO projects (name, path, preferred_agents, icon, icon_color, host_ids, workspace_id) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(
+    project.name,
+    project.path,
+    JSON.stringify(project.preferredAgents),
+    project.icon ?? null,
+    project.iconColor ?? null,
+    project.hostIds ? JSON.stringify(project.hostIds) : null,
+    project.workspaceId ?? "personal"
+  );
+}
+function dbUpdateProject(name, updates) {
+  const sets = [];
+  const params = [];
+  if (updates.path !== void 0) {
+    sets.push("path = ?");
+    params.push(updates.path);
+  }
+  if (updates.preferredAgents !== void 0) {
+    sets.push("preferred_agents = ?");
+    params.push(JSON.stringify(updates.preferredAgents));
+  }
+  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.hostIds !== void 0) {
+    sets.push("host_ids = ?");
+    params.push(JSON.stringify(updates.hostIds));
+  }
+  if (updates.workspaceId !== void 0) {
+    sets.push("workspace_id = ?");
+    params.push(updates.workspaceId);
+  }
+  if (sets.length === 0) return;
+  params.push(name);
+  getDb().prepare(`UPDATE projects SET ${sets.join(", ")} WHERE name = ?`).run(...params);
+}
+function dbDeleteProject(name) {
+  const d = getDb();
+  d.transaction(() => {
+    d.prepare("DELETE FROM tasks WHERE project_name = ?").run(name);
+    d.prepare("DELETE FROM projects WHERE name = ?").run(name);
+  })();
+}
+function dbListWorkflows() {
+  const rows = getDb().prepare("SELECT * FROM workflows").all();
+  return rows.map(rowToWorkflow);
+}
+function dbInsertWorkflow(workflow) {
+  getDb().prepare(
+    `INSERT INTO workflows (id, name, icon, icon_color, nodes, edges, enabled, last_run_at, last_run_status, stagger_delay_ms, workspace_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    workflow.id,
+    workflow.name,
+    workflow.icon,
+    workflow.iconColor,
+    JSON.stringify(workflow.nodes),
+    JSON.stringify(workflow.edges),
+    workflow.enabled ? 1 : 0,
+    workflow.lastRunAt ?? null,
+    workflow.lastRunStatus ?? null,
+    workflow.staggerDelayMs ?? null,
+    workflow.workspaceId ?? "personal"
+  );
+}
+function dbUpdateWorkflow(id, updates) {
+  const sets = [];
+  const params = [];
+  if (updates.name !== void 0) {
+    sets.push("name = ?");
+    params.push(updates.name);
+  }
+  if (updates.nodes !== void 0) {
+    sets.push("nodes = ?");
+    params.push(JSON.stringify(updates.nodes));
+  }
+  if (updates.edges !== void 0) {
+    sets.push("edges = ?");
+    params.push(JSON.stringify(updates.edges));
+  }
+  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.enabled !== void 0) {
+    sets.push("enabled = ?");
+    params.push(updates.enabled ? 1 : 0);
+  }
+  if (updates.staggerDelayMs !== void 0) {
+    sets.push("stagger_delay_ms = ?");
+    params.push(updates.staggerDelayMs);
+  }
+  if (updates.workspaceId !== void 0) {
+    sets.push("workspace_id = ?");
+    params.push(updates.workspaceId);
+  }
+  if (sets.length === 0) return;
+  params.push(id);
+  getDb().prepare(`UPDATE workflows SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+}
+function dbDeleteWorkflow(id) {
+  getDb().prepare("DELETE FROM workflows WHERE id = ?").run(id);
+}
+function rowToTask(r) {
+  return {
+    id: r.id,
+    projectName: r.project_name,
+    title: r.title,
+    description: r.description,
+    status: r.status,
+    order: r.order,
+    ...r.assigned_session_id != null && { assignedSessionId: r.assigned_session_id },
+    ...r.assigned_agent != null && { assignedAgent: r.assigned_agent },
+    ...r.agent_session_id != null && { agentSessionId: r.agent_session_id },
+    ...r.branch != null && { branch: r.branch },
+    ...r.use_worktree != null && r.use_worktree !== 0 && { useWorktree: true },
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    ...r.completed_at != null && { completedAt: r.completed_at }
+  };
+}
+function rowToProject(r) {
+  return {
+    name: r.name,
+    path: r.path,
+    preferredAgents: JSON.parse(r.preferred_agents),
+    ...r.icon != null && { icon: r.icon },
+    ...r.icon_color != null && { iconColor: r.icon_color },
+    ...r.host_ids != null && { hostIds: JSON.parse(r.host_ids) },
+    workspaceId: r.workspace_id ?? "personal"
+  };
+}
+function rowToWorkflow(r) {
+  return {
+    id: r.id,
+    name: r.name,
+    icon: r.icon,
+    iconColor: r.icon_color,
+    nodes: JSON.parse(r.nodes),
+    edges: JSON.parse(r.edges),
+    enabled: r.enabled === 1,
+    ...r.last_run_at != null && { lastRunAt: r.last_run_at },
+    ...r.last_run_status != null && { lastRunStatus: r.last_run_status },
+    ...r.stagger_delay_ms != null && { staggerDelayMs: r.stagger_delay_ms },
+    workspaceId: r.workspace_id ?? "personal"
+  };
+}
+function rowToWorkspace(r) {
+  return {
+    id: r.id,
+    name: r.name,
+    ...r.icon != null && { icon: r.icon },
+    ...r.icon_color != null && { iconColor: r.icon_color },
+    order: r.order
+  };
+}
+
+// ../server/src/config-manager.ts
+var DB_DIR = path2.join(os2.homedir(), ".vibegrid");
+var ConfigManager = class {
+  changeCallbacks = [];
+  dbWatcher = null;
+  debounceTimer = null;
+  init() {
+    initDatabase();
+  }
+  close() {
+    this.stopWatchingDb();
+    closeDatabase();
+  }
+  loadConfig() {
+    try {
+      return loadConfig();
+    } catch (err) {
+      logger_default.error("[config-manager] loadConfig failed, returning defaults:", err);
+      return {
+        version: 1,
+        defaults: {
+          shell: process.platform === "win32" ? process.env.COMSPEC || "powershell.exe" : process.env.SHELL || "/bin/zsh",
+          fontSize: 13,
+          theme: "dark"
+        },
+        projects: [],
+        agentCommands: { ...DEFAULT_AGENT_COMMANDS },
+        workflows: [],
+        tasks: []
+      };
+    }
+  }
+  saveConfig(config) {
+    try {
+      saveConfig(config);
+    } catch (err) {
+      logger_default.error("[config-manager] saveConfig failed:", err);
+      throw err;
+    }
+  }
+  /** Register a callback for when config changes from within the main process */
+  onConfigChanged(callback) {
+    this.changeCallbacks.push(callback);
+  }
+  /** Notify all registered callbacks (call after main-process config mutations) */
+  notifyChanged() {
+    const config = this.loadConfig();
+    for (const cb of this.changeCallbacks) {
+      cb(config);
+    }
+  }
+  /**
+   * Watch the SQLite WAL file for external writes (e.g. MCP stdio process).
+   * On change, debounce and notify callbacks so the GUI picks up fresh data.
+   */
+  watchDb() {
+    if (this.dbWatcher) return;
+    try {
+      this.dbWatcher = fs2.watch(DB_DIR, (eventType, filename) => {
+        if (!filename || !filename.endsWith(".db-wal")) return;
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+          this.notifyChanged();
+        }, 1e3);
+      });
+    } catch {
+    }
+  }
+  stopWatchingDb() {
+    if (this.dbWatcher) {
+      this.dbWatcher.close();
+      this.dbWatcher = null;
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+  // No-ops -- retained for API compatibility during transition
+  watchConfig(_callback) {
+  }
+  stopWatching() {
+  }
+};
+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";
+
+// ../server/src/git-utils.ts
+import { execFileSync } from "child_process";
+import path3 from "path";
+import fs3 from "fs";
+import crypto 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 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;
+      }
+      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;
+  }
+}
+
+// ../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 { EventEmitter as EventEmitter2 } from "events";
+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) {
+    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) continue;
+      const trigger = getTriggerConfig(wf);
+      if (!trigger) continue;
+      if (trigger.triggerType === "recurring" && !this.cronJobs.has(wf.id)) {
+        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) {
+    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 path4 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 ?? "",
+        status,
+        order: maxOrder + 1,
+        createdAt: now,
+        updatedAt: now,
+        ...args.branch && { branch: args.branch },
+        ...args.use_worktree && { useWorktree: args.use_worktree },
+        ...args.assigned_agent && { assignedAgent: args.assigned_agent },
+        ...(status === "done" || status === "cancelled") && { completedAt: now }
+      };
+      dbInsertTask(task);
+      configManager2.notifyChanged();
+      return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+    }
+  );
+  server.tool("get_task", "Get a task by ID", { id: V.id.describe("Task ID") }, async (args) => {
+    const task = dbGetTask(args.id);
+    if (!task) {
+      return {
+        content: [{ type: "text", text: `Error: task "${args.id}" not found` }],
+        isError: true
+      };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+  });
+  server.tool(
+    "update_task",
+    "Update a task's properties",
+    {
+      id: V.id.describe("Task ID"),
+      title: V.title.optional().describe("New title"),
+      description: V.description.optional().describe("New description"),
+      status: z2.enum(TASK_STATUSES).optional().describe("New status"),
+      branch: V.shortText.optional().describe("Git branch"),
+      use_worktree: z2.boolean().optional().describe("Use git worktree"),
+      assigned_agent: z2.enum(AGENT_TYPES).optional().describe("Assigned agent type"),
+      order: z2.number().optional().describe("Queue order")
+    },
+    async (args) => {
+      const task = dbGetTask(args.id);
+      if (!task) {
+        return {
+          content: [{ type: "text", text: `Error: task "${args.id}" not found` }],
+          isError: true
+        };
+      }
+      const updates = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      if (args.title !== void 0) updates.title = args.title;
+      if (args.description !== void 0) updates.description = args.description;
+      if (args.branch !== void 0) updates.branch = args.branch;
+      if (args.use_worktree !== void 0) updates.useWorktree = args.use_worktree;
+      if (args.assigned_agent !== void 0)
+        updates.assignedAgent = args.assigned_agent;
+      if (args.order !== void 0) updates.order = args.order;
+      if (args.status !== void 0) {
+        const newStatus = args.status;
+        const wasDone = task.status === "done" || task.status === "cancelled";
+        const isDone = newStatus === "done" || newStatus === "cancelled";
+        updates.status = newStatus;
+        if (isDone && !wasDone) updates.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        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) }] };
+    }
+  );
+  server.tool(
+    "delete_task",
+    "Delete a task by ID",
+    { id: V.id.describe("Task ID") },
+    async (args) => {
+      const task = dbGetTask(args.id);
+      if (!task) {
+        return {
+          content: [{ type: "text", text: `Error: task "${args.id}" not found` }],
+          isError: true
+        };
+      }
+      dbDeleteTask(args.id);
+      configManager2.notifyChanged();
+      return { content: [{ type: "text", text: `Deleted task: ${task.title}` }] };
+    }
+  );
+  server.tool(
+    "get_my_context",
+    "Get your current task and project context. Auto-detects based on your working directory. Call this at the start of a session to understand what you are working on.",
+    {
+      cwd: V.absolutePath.optional().describe(
+        "Your current working directory (auto-detected if omitted). Used to match against known projects and task worktrees."
+      ),
+      task_id: V.id.optional().describe("Specific task ID to get context for (overrides auto-detection)")
+    },
+    async (args) => {
+      if (args.task_id) {
+        const task = dbGetTask(args.task_id);
+        if (!task) {
+          return {
+            content: [{ type: "text", text: `Error: task "${args.task_id}" not found` }],
+            isError: true
+          };
+        }
+        const project = dbGetProject(task.projectName);
+        const siblingTasks = dbListTasks(task.projectName);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  task,
+                  project: project ?? void 0,
+                  siblingTasks: siblingTasks.filter((t) => t.id !== task.id).map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    status: t.status,
+                    branch: t.branch
+                  }))
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      const cwd = args.cwd || process.cwd();
+      const normalizedCwd = path4.resolve(cwd);
+      const projects = dbListProjects();
+      let matchedProject = null;
+      let matchLen = 0;
+      for (const p of projects) {
+        const normalizedPath = path4.resolve(p.path);
+        if (normalizedCwd.startsWith(normalizedPath) && normalizedPath.length > matchLen) {
+          matchedProject = p;
+          matchLen = normalizedPath.length;
+        }
+      }
+      if (!matchedProject) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  message: "No matching project found for current directory.",
+                  cwd: normalizedCwd,
+                  hint: "Use list_projects to see available projects, or pass a task_id directly."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      const projectTasks = dbListTasks(matchedProject.name);
+      let matchedTask = null;
+      for (const t of projectTasks) {
+        if (t.worktreePath) {
+          const normalizedWorktree = path4.resolve(t.worktreePath);
+          if (normalizedCwd.startsWith(normalizedWorktree)) {
+            matchedTask = t;
+            break;
+          }
+        }
+      }
+      if (!matchedTask) {
+        matchedTask = projectTasks.find((t) => t.status === "in_progress") ?? null;
+      }
+      const result = {
+        project: {
+          name: matchedProject.name,
+          path: matchedProject.path,
+          preferredAgents: matchedProject.preferredAgents
+        },
+        cwd: normalizedCwd
+      };
+      if (matchedTask) {
+        result.task = matchedTask;
+        result.siblingTasks = projectTasks.filter((t) => t.id !== matchedTask.id).map((t) => ({ id: t.id, title: t.title, status: t.status, branch: t.branch }));
+      } else {
+        result.message = "No specific task matched. Showing all project tasks.";
+        result.tasks = projectTasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+          status: t.status,
+          branch: t.branch
+        }));
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+}
+
+// src/tools/projects.ts
+import { z as z3 } from "zod";
+var AGENT_TYPES2 = [
+  "claude",
+  "copilot",
+  "codex",
+  "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) }] };
+  });
+  server.tool(
+    "create_project",
+    "Create a new project",
+    {
+      name: V.name.describe("Project name (unique identifier)"),
+      path: V.absolutePath.describe("Absolute path to project directory"),
+      preferred_agents: z3.array(z3.enum(AGENT_TYPES2)).optional().describe("Preferred agent types"),
+      icon: V.shortText.optional().describe("Lucide icon name"),
+      icon_color: V.hexColor.optional().describe("Hex color for icon")
+    },
+    async (args) => {
+      if (dbGetProject(args.name)) {
+        return {
+          content: [{ type: "text", text: `Error: project "${args.name}" already exists` }],
+          isError: true
+        };
+      }
+      const project = {
+        name: args.name,
+        path: args.path,
+        preferredAgents: args.preferred_agents ?? [],
+        ...args.icon && { icon: args.icon },
+        ...args.icon_color && { iconColor: args.icon_color }
+      };
+      dbInsertProject(project);
+      configManager2.notifyChanged();
+      return { content: [{ type: "text", text: JSON.stringify(project, null, 2) }] };
+    }
+  );
+  server.tool(
+    "update_project",
+    "Update a project's properties",
+    {
+      name: V.name.describe("Project name (identifier, cannot be changed)"),
+      path: V.absolutePath.optional().describe("New project path"),
+      preferred_agents: z3.array(z3.enum(AGENT_TYPES2)).optional().describe("Preferred agent types"),
+      icon: V.shortText.optional().describe("Lucide icon name"),
+      icon_color: V.hexColor.optional().describe("Hex color for icon")
+    },
+    async (args) => {
+      if (!dbGetProject(args.name)) {
+        return {
+          content: [{ type: "text", text: `Error: project "${args.name}" not found` }],
+          isError: true
+        };
+      }
+      const updates = {};
+      if (args.path !== void 0) updates.path = args.path;
+      if (args.preferred_agents !== void 0)
+        updates.preferredAgents = args.preferred_agents;
+      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) }] };
+    }
+  );
+  server.tool(
+    "delete_project",
+    "Delete a project and all its tasks",
+    { name: V.name.describe("Project name") },
+    async (args) => {
+      if (!dbGetProject(args.name)) {
+        return {
+          content: [{ type: "text", text: `Error: project "${args.name}" not found` }],
+          isError: true
+        };
+      }
+      dbDeleteProject(args.name);
+      configManager2.notifyChanged();
+      return { content: [{ type: "text", text: `Deleted project: ${args.name}` }] };
+    }
+  );
+}
+
+// src/tools/sessions.ts
+import { z as z4 } from "zod";
+var AGENT_TYPES3 = [
+  "claude",
+  "copilot",
+  "codex",
+  "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) }] };
+  });
+  server.tool(
+    "launch_agent",
+    "Launch an AI agent in a new terminal session",
+    {
+      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 = ptyManager2.createPty(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 agent: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "kill_session",
+    "Kill a terminal session",
+    { id: V.id.describe("Session ID to kill") },
+    async (args) => {
+      try {
+        ptyManager2.killPty(args.id);
+        return { content: [{ type: "text", text: `Killed session: ${args.id}` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error killing session: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "write_to_terminal",
+    "Send input to a running terminal session",
+    {
+      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);
+        return { content: [{ type: "text", text: `Wrote to session: ${args.id}` }] };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error writing to terminal: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/workflows.ts
+import crypto4 from "crypto";
+import { z as z5 } from "zod";
+var launchAgentConfigSchema = z5.object({
+  agentType: z5.enum(["claude", "copilot", "codex", "opencode", "gemini"]),
+  projectName: V.name,
+  projectPath: V.absolutePath,
+  args: z5.array(V.shortText).optional(),
+  displayName: V.shortText.optional(),
+  branch: V.shortText.optional(),
+  useWorktree: z5.boolean().optional(),
+  remoteHostId: V.id.optional(),
+  prompt: V.prompt.optional(),
+  promptDelayMs: z5.number().optional(),
+  taskId: V.id.optional(),
+  taskFromQueue: z5.boolean().optional()
+});
+var triggerConfigSchema = z5.union([
+  z5.object({ triggerType: z5.literal("manual") }),
+  z5.object({ triggerType: z5.literal("once"), runAt: V.shortText }),
+  z5.object({
+    triggerType: z5.literal("recurring"),
+    cron: V.shortText,
+    timezone: V.shortText.optional()
+  }),
+  z5.object({ triggerType: z5.literal("taskCreated"), projectFilter: V.name.optional() }),
+  z5.object({
+    triggerType: z5.literal("taskStatusChanged"),
+    projectFilter: V.name.optional(),
+    fromStatus: z5.enum(["todo", "in_progress", "in_review", "done", "cancelled"]).optional(),
+    toStatus: z5.enum(["todo", "in_progress", "in_review", "done", "cancelled"]).optional()
+  })
+]);
+var nodeSchema = z5.object({
+  id: V.id,
+  type: z5.enum(["trigger", "launchAgent"]),
+  label: V.shortText,
+  config: z5.record(z5.unknown()),
+  position: z5.object({ x: z5.number(), y: z5.number() })
+});
+var edgeSchema = z5.object({
+  id: V.id,
+  source: V.id,
+  target: V.id
+});
+function buildGraphFromFlat(trigger, actions) {
+  const nodes = [];
+  const edges = [];
+  const triggerNode = {
+    id: crypto4.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,
+    position: { x: 0, y: 0 }
+  };
+  nodes.push(triggerNode);
+  let prevId = triggerNode.id;
+  const NODE_GAP = 140;
+  for (let i = 0; i < actions.length; i++) {
+    const action = actions[i];
+    const nodeId = crypto4.randomUUID();
+    nodes.push({
+      id: nodeId,
+      type: "launchAgent",
+      label: `Launch ${action.agentType}`,
+      config: action,
+      position: { x: 0, y: (i + 1) * NODE_GAP }
+    });
+    edges.push({
+      id: crypto4.randomUUID(),
+      source: prevId,
+      target: nodeId
+    });
+    prevId = nodeId;
+  }
+  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) }] };
+  });
+  server.tool(
+    "create_workflow",
+    "Create a new workflow. Accepts either full nodes/edges or a convenience flat format (trigger + actions array).",
+    z5.object({
+      name: V.title.describe("Workflow name"),
+      trigger: triggerConfigSchema.optional().describe("Trigger config (convenience mode). Defaults to manual."),
+      actions: z5.array(launchAgentConfigSchema).optional().describe("Actions to execute (convenience mode). Auto-generates graph."),
+      nodes: z5.array(nodeSchema).optional().describe("Full graph nodes (advanced mode)"),
+      edges: z5.array(edgeSchema).optional().describe("Full graph edges (advanced mode)"),
+      icon: V.shortText.optional().describe("Lucide icon name (default: zap)"),
+      icon_color: V.hexColor.optional().describe("Hex color (default: #6366f1)"),
+      enabled: z5.boolean().optional().describe("Whether workflow is enabled (default: true)"),
+      stagger_delay_ms: z5.number().optional().describe("Delay in ms between actions")
+    }),
+    async (args) => {
+      let nodes;
+      let edges;
+      if (args.nodes && args.edges) {
+        nodes = args.nodes;
+        edges = args.edges;
+      } else {
+        const trigger = args.trigger ?? { triggerType: "manual" };
+        const actions = args.actions ?? [];
+        const graph = buildGraphFromFlat(trigger, actions);
+        nodes = graph.nodes;
+        edges = graph.edges;
+      }
+      const workflow = {
+        id: crypto4.randomUUID(),
+        name: args.name,
+        icon: args.icon ?? "zap",
+        iconColor: args.icon_color ?? "#6366f1",
+        nodes,
+        edges,
+        enabled: args.enabled ?? true,
+        ...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) }] };
+    }
+  );
+  server.tool(
+    "update_workflow",
+    "Update a workflow's properties",
+    z5.object({
+      id: V.id.describe("Workflow ID"),
+      name: V.title.optional(),
+      nodes: z5.array(nodeSchema).optional(),
+      edges: z5.array(edgeSchema).optional(),
+      icon: V.shortText.optional(),
+      icon_color: V.hexColor.optional(),
+      enabled: z5.boolean().optional(),
+      stagger_delay_ms: z5.number().optional()
+    }),
+    async (args) => {
+      const workflows = dbListWorkflows();
+      const workflow = workflows.find((w) => w.id === args.id);
+      if (!workflow) {
+        return {
+          content: [{ type: "text", text: `Error: workflow "${args.id}" not found` }],
+          isError: true
+        };
+      }
+      const updates = {};
+      if (args.name !== void 0) updates.name = args.name;
+      if (args.nodes !== void 0) updates.nodes = args.nodes;
+      if (args.edges !== void 0) updates.edges = args.edges;
+      if (args.icon !== void 0) updates.icon = args.icon;
+      if (args.icon_color !== void 0) updates.iconColor = args.icon_color;
+      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) }]
+      };
+    }
+  );
+  server.tool(
+    "delete_workflow",
+    "Delete a workflow",
+    { id: V.id.describe("Workflow ID") },
+    async (args) => {
+      const workflows = dbListWorkflows();
+      const workflow = workflows.find((w) => w.id === args.id);
+      if (!workflow) {
+        return {
+          content: [{ type: "text", text: `Error: workflow "${args.id}" not found` }],
+          isError: true
+        };
+      }
+      dbDeleteWorkflow(args.id);
+      scheduler2.syncSchedules(dbListWorkflows());
+      configManager2.notifyChanged();
+      return { content: [{ type: "text", text: `Deleted workflow: ${workflow.name}` }] };
+    }
+  );
+}
+
+// src/tools/git.ts
+function registerGitTools(server) {
+  server.tool(
+    "list_branches",
+    "List git branches for a project",
+    { project_path: V.absolutePath.describe("Absolute path to project directory") },
+    async (args) => {
+      try {
+        const local = listBranches(args.project_path);
+        const current = getGitBranch(args.project_path);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ current, branches: local }, null, 2) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error listing branches: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_diff",
+    "Get git diff for a project (staged and unstaged changes)",
+    { project_path: V.absolutePath.describe("Absolute path to project directory") },
+    async (args) => {
+      try {
+        const result = getGitDiffFull(args.project_path);
+        if (!result) {
+          return {
+            content: [{ type: "text", text: "No changes detected or not a git repository" }]
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error getting diff: ${err}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/config.ts
+function registerConfigTools(server, deps) {
+  const { configManager: configManager2 } = deps;
+  server.tool(
+    "get_config",
+    "Get the full VibeGrid configuration (projects, tasks, workflows, settings)",
+    async () => {
+      const config = configManager2.loadConfig();
+      return { content: [{ type: "text", text: JSON.stringify(config, null, 2) }] };
+    }
+  );
+}
+
+// src/server.ts
+function createMcpServer(deps, 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);
+  return server;
+}
+
+// src/index.ts
+var _origError = console.error;
+console.log = (...args) => _origError("[mcp]", ...args);
+console.info = (...args) => _origError("[mcp]", ...args);
+console.debug = (...args) => _origError("[mcp:debug]", ...args);
+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 server = createMcpServer({ configManager, ptyManager, scheduler }, "0.1.1");
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  transport.onclose = () => {
+    scheduler.stopAll();
+    ptyManager.killAll();
+    configManager.close();
+    process.exit(0);
+  };
+}
+main().catch((err) => {
+  console.error("Failed to start MCP server:", err);
+  process.exit(1);
+});