@vornrun/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2507 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "module";
+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 "libsql";
+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",
+  // Always write to stderr so the main process can capture via electron-log.
+  // Previously production used the default (stdout), but nothing reads stdout
+  // after the initial port banner — so all server logs were silently dropped.
+  transport: { target: "pino/file", options: { destination: 2 } }
+});
+var logger_default = log;
+
+// ../shared/src/types.ts
+var DEFAULT_WORKSPACE = {
+  id: "personal",
+  name: "Personal",
+  icon: "User",
+  iconColor: "#6b7280",
+  order: 0
+};
+
+// ../server/src/database.ts
+var CONFIG_DIR = path.join(os.homedir(), ".vorn");
+var DB_PATH = path.join(CONFIG_DIR, "vorn.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 dbSignalChange() {
+  try {
+    const signalPath = path.join(CONFIG_DIR, ".db-signal");
+    fs.writeFileSync(signalPath, Date.now().toString());
+  } catch {
+  }
+}
+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 '[]',
+      headless_args TEXT,
+      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,
+      auth_method TEXT DEFAULT 'agent',
+      ssh_key_path TEXT,
+      credential_id TEXT,
+      encrypted_password TEXT,
+      ssh_options TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS ssh_keys (
+      id TEXT PRIMARY KEY,
+      label TEXT NOT NULL,
+      encrypted_private_key TEXT NOT NULL,
+      public_key TEXT,
+      certificate TEXT,
+      key_type TEXT,
+      created_at TEXT NOT NULL
+    );
+
+    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,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      worktree_name TEXT
+    );
+
+    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);
+
+    CREATE TABLE IF NOT EXISTS session_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      agent_type TEXT,
+      branch TEXT,
+      status TEXT NOT NULL DEFAULT 'running',
+      started_at TEXT NOT NULL,
+      completed_at TEXT,
+      exit_code INTEGER,
+      logs TEXT,
+      project_name TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_logs_task ON session_logs(task_id);
+    CREATE INDEX IF NOT EXISTS idx_session_logs_session ON session_logs(session_id);
+
+    CREATE TABLE IF NOT EXISTS session_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      metadata TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_session ON session_events(session_id, timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_session_events_type ON session_events(event_type, timestamp DESC);
+  `);
+  migrateSchema(d);
+  verifySchema(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)");
+  }
+  if (version < 2) {
+    d.transaction(() => {
+      const hostCols = d.prepare("PRAGMA table_info(remote_hosts)").all();
+      if (!hostCols.some((c) => c.name === "auth_method")) {
+        d.exec("ALTER TABLE remote_hosts ADD COLUMN auth_method TEXT");
+        d.exec("ALTER TABLE remote_hosts ADD COLUMN credential_id TEXT");
+        d.exec("ALTER TABLE remote_hosts ADD COLUMN encrypted_password TEXT");
+        d.exec(
+          "UPDATE remote_hosts SET auth_method = CASE WHEN ssh_key_path IS NOT NULL AND ssh_key_path != '' THEN 'key-file' ELSE 'agent' END"
+        );
+      }
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS ssh_keys (
+          id TEXT PRIMARY KEY,
+          label TEXT NOT NULL,
+          encrypted_private_key TEXT NOT NULL,
+          public_key TEXT,
+          certificate TEXT,
+          key_type TEXT,
+          created_at TEXT NOT NULL
+        )
+      `);
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '2')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 2 (ssh credential vault)");
+  }
+  if (version < 3) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      if (!sessionCols.some((c) => c.name === "sort_order")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '3')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 3 (session sort order)");
+  }
+  if (version < 4) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      if (!sessionCols.some((c) => c.name === "worktree_name")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN worktree_name TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '4')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 4 (worktree name)");
+  }
+  if (version < 5) {
+    d.transaction(() => {
+      const agentCols = d.prepare("PRAGMA table_info(agent_commands)").all();
+      if (!agentCols.some((c) => c.name === "headless_args")) {
+        d.exec("ALTER TABLE agent_commands ADD COLUMN headless_args TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '5')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 5 (headless args)");
+  }
+  if (version < 6) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      if (!sessionCols.some((c) => c.name === "claude_session_id")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN claude_session_id TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '6')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 6 (claude session id)");
+  }
+}
+function verifySchema(d) {
+  const expectedByTable = {
+    projects: [
+      {
+        column: "workspace_id",
+        ddl: "ALTER TABLE projects ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'personal'"
+      }
+    ],
+    workflows: [
+      {
+        column: "workspace_id",
+        ddl: "ALTER TABLE workflows ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'personal'"
+      }
+    ],
+    remote_hosts: [
+      { column: "auth_method", ddl: "ALTER TABLE remote_hosts ADD COLUMN auth_method TEXT" },
+      { column: "credential_id", ddl: "ALTER TABLE remote_hosts ADD COLUMN credential_id TEXT" },
+      {
+        column: "encrypted_password",
+        ddl: "ALTER TABLE remote_hosts ADD COLUMN encrypted_password TEXT"
+      }
+    ],
+    sessions: [
+      {
+        column: "sort_order",
+        ddl: "ALTER TABLE sessions ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0"
+      },
+      { column: "worktree_name", ddl: "ALTER TABLE sessions ADD COLUMN worktree_name TEXT" },
+      { column: "claude_session_id", ddl: "ALTER TABLE sessions ADD COLUMN claude_session_id TEXT" }
+    ],
+    agent_commands: [
+      {
+        column: "headless_args",
+        ddl: "ALTER TABLE agent_commands ADD COLUMN headless_args TEXT"
+      }
+    ]
+  };
+  for (const [table, columns] of Object.entries(expectedByTable)) {
+    const existing = new Set(
+      d.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name)
+    );
+    for (const { column, ddl } of columns) {
+      if (existing.has(column)) continue;
+      try {
+        d.exec(ddl);
+        logger_default.warn(`[database] self-heal: added missing column ${table}.${column}`);
+      } catch (err) {
+        logger_default.error(`[database] self-heal: failed to add ${table}.${column}:`, err);
+      }
+    }
+  }
+}
+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
+    },
+    ...map.mainViewMode !== void 0 && {
+      mainViewMode: map.mainViewMode
+    },
+    ...map.layoutMode !== void 0 && {
+      layoutMode: map.layoutMode
+    },
+    ...map.updateChannel !== void 0 && {
+      updateChannel: map.updateChannel
+    },
+    ...map.webAccessEnabled !== void 0 && {
+      webAccessEnabled: map.webAccessEnabled
+    },
+    ...map.mobileAccessEnabled !== void 0 && {
+      mobileAccessEnabled: map.mobileAccessEnabled
+    },
+    ...map.networkAccessEnabled !== void 0 && {
+      networkAccessEnabled: map.networkAccessEnabled
+    },
+    ...map.showHeadlessAgents !== void 0 && {
+      showHeadlessAgents: map.showHeadlessAgents
+    },
+    ...map.headlessRetentionMinutes !== void 0 && {
+      headlessRetentionMinutes: map.headlessRetentionMinutes
+    }
+  };
+}
+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.headless_args != null && { headlessArgs: JSON.parse(r.headless_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.auth_method != null && { authMethod: r.auth_method },
+    ...r.ssh_key_path != null && { sshKeyPath: r.ssh_key_path },
+    ...r.credential_id != null && { credentialId: r.credential_id },
+    ...r.encrypted_password != null && { encryptedPassword: r.encrypted_password },
+    ...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, headless_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.headlessArgs ? JSON.stringify(cmd.headlessArgs) : null,
+            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, auth_method, ssh_key_path, credential_id, encrypted_password, ssh_options) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    for (const h of config.remoteHosts ?? []) {
+      insertHost.run(
+        h.id,
+        h.label,
+        h.hostname,
+        h.user,
+        h.port,
+        h.authMethod ?? "agent",
+        h.sshKeyPath ?? null,
+        h.credentialId ?? null,
+        h.encryptedPassword ?? 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 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,
+    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
+  };
+}
+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(), ".vorn");
+var ConfigManager = class {
+  changeCallbacks = [];
+  dbWatcher = null;
+  debounceTimer = null;
+  cachedConfig = null;
+  init() {
+    initDatabase();
+  }
+  close() {
+    this.stopWatchingDb();
+    closeDatabase();
+  }
+  loadConfig() {
+    if (this.cachedConfig) return this.cachedConfig;
+    try {
+      const config = loadConfig();
+      this.cachedConfig = config;
+      return config;
+    } 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);
+      this.cachedConfig = null;
+    } 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() {
+    this.cachedConfig = null;
+    const config = this.loadConfig();
+    for (const cb of this.changeCallbacks) {
+      cb(config);
+    }
+  }
+  /**
+   * Watch for external DB writes (e.g. MCP stdio process).
+   * Detects: .db-signal (explicit), .db-wal changes, and .db changes (post-checkpoint).
+   */
+  watchDb() {
+    if (this.dbWatcher) return;
+    const WATCH_SUFFIXES = [".db-signal", ".db-wal", ".db"];
+    try {
+      this.dbWatcher = fs2.watch(DB_DIR, (eventType, filename) => {
+        if (!filename || !WATCH_SUFFIXES.some((s) => filename.endsWith(s))) return;
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+          this.notifyChanged();
+        }, 300);
+      });
+    } 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();
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/tasks.ts
+import crypto from "crypto";
+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
+};
+
+// 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));
+      }
+      if (args.assigned_agent) {
+        tasks = tasks.filter((t) => t.assignedAgent === args.assigned_agent);
+      }
+      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: crypto.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);
+      dbSignalChange();
+      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);
+      dbSignalChange();
+      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);
+      dbSignalChange();
+      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 = path3.resolve(cwd);
+      const projects = dbListProjects();
+      let matchedProject = null;
+      let matchLen = 0;
+      for (const p of projects) {
+        const normalizedPath = path3.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 = path3.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) {
+  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",
+    {
+      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);
+      dbSignalChange();
+      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);
+      dbSignalChange();
+      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);
+      dbSignalChange();
+      return { content: [{ type: "text", text: `Deleted project: ${args.name}` }] };
+    }
+  );
+}
+
+// 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 { execFileSync } from "child_process";
+import { WebSocket } from "ws";
+var PORT_FILE = path4.join(os3.homedir(), ".vorn", "ws-port");
+var TIMEOUT_MS = 1e4;
+var IS_WIN = process.platform === "win32";
+var PORT_FILE_MISSING_MSG = IS_WIN ? `Vorn port file not found (~/.vorn/ws-port).
+The app may be running but the port file was deleted (e.g. by another instance shutting down).
+To fix, find the Vorn process and its listening port:
+  powershell -c "Get-NetTCPConnection -State Listen -OwningProcess (Get-Process Vorn).Id | Select LocalPort"
+Then write the WS port to the file:
+  echo {"port":<PORT>,"pid":<PID>} > %USERPROFILE%\\.vorn\\ws-port
+Or restart Vorn to regenerate it.` : `Vorn port file not found (~/.vorn/ws-port).
+The app may be running but the port file was deleted (e.g. by another instance shutting down).
+To fix, run:  lsof -iTCP -sTCP:LISTEN -P | grep Vorn
+Then write the WS port (the one on *:<port>) to the file:
+  echo '{"port":<PORT>,"pid":<PID>}' > ~/.vorn/ws-port
+Or restart Vorn to regenerate it.`;
+var PORT_FILE_INVALID_MSG = `Vorn port file exists but contains invalid data (~/.vorn/ws-port).
+Delete it and restart Vorn, or overwrite it with the correct port:
+  ${IS_WIN ? "del %USERPROFILE%\\.vorn\\ws-port" : "rm ~/.vorn/ws-port"}`;
+var rpcId = 0;
+var cachedPort = null;
+var cacheTimestamp = 0;
+var CACHE_TTL_MS = 5e3;
+var EXEC_OPTS = {
+  encoding: "utf-8",
+  timeout: 5e3,
+  stdio: ["pipe", "pipe", "pipe"]
+};
+function discoverPort() {
+  try {
+    if (IS_WIN) {
+      const taskOut = execFileSync(
+        "tasklist",
+        ["/FI", "IMAGENAME eq Vorn.exe", "/FO", "CSV", "/NH"],
+        EXEC_OPTS
+      );
+      const pidMatch = taskOut.match(/"Vorn\.exe","(\d+)"/);
+      if (!pidMatch) return null;
+      const pid = pidMatch[1];
+      const lines = execFileSync("netstat", ["-ano"], EXEC_OPTS).split("\n");
+      let fallback = null;
+      for (const line of lines) {
+        if (!line.includes("LISTENING") || !line.trim().endsWith(pid)) continue;
+        const m = line.match(/(?:0\.0\.0\.0|127\.0\.0\.1):(\d+)/);
+        if (!m) continue;
+        if (line.includes("0.0.0.0")) return parseInt(m[1], 10);
+        fallback ??= parseInt(m[1], 10);
+      }
+      return fallback;
+    } else {
+      const lines = execFileSync("lsof", ["-iTCP", "-sTCP:LISTEN", "-P", "-n"], EXEC_OPTS).split(
+        "\n"
+      );
+      let fallback = null;
+      for (const line of lines) {
+        if (!line.includes("Vorn")) continue;
+        if (line.includes("*:")) {
+          const m = line.match(/\*:(\d+)/);
+          if (m) return parseInt(m[1], 10);
+        }
+        if (!fallback) {
+          const m = line.match(/:(\d+)\s/);
+          if (m) fallback = parseInt(m[1], 10);
+        }
+      }
+      return fallback;
+    }
+  } catch {
+  }
+  return null;
+}
+function discoverAndHeal() {
+  const now = Date.now();
+  if (cachedPort && now - cacheTimestamp < CACHE_TTL_MS) return { port: cachedPort };
+  const discovered = discoverPort();
+  cachedPort = discovered;
+  cacheTimestamp = now;
+  if (discovered) {
+    try {
+      fs3.mkdirSync(path4.dirname(PORT_FILE), { recursive: true });
+      fs3.writeFileSync(PORT_FILE, JSON.stringify({ port: discovered }), "utf-8");
+    } catch {
+    }
+    return { port: discovered };
+  }
+  return { port: null, reason: "missing" };
+}
+function readPort() {
+  try {
+    const raw = fs3.readFileSync(PORT_FILE, "utf-8").trim();
+    if (!raw) return { port: null, reason: "invalid" };
+    if (raw.startsWith("{")) {
+      const parsed = JSON.parse(raw);
+      const p2 = parsed?.port;
+      const pid = parsed?.pid;
+      if (typeof p2 !== "number" || !Number.isFinite(p2) || p2 <= 0) {
+        return { port: null, reason: "invalid" };
+      }
+      if (typeof pid === "number" && Number.isInteger(pid) && pid > 0) {
+        try {
+          process.kill(pid, 0);
+        } catch (err) {
+          if (err.code === "EPERM") return { port: p2 };
+          return discoverAndHeal();
+        }
+      }
+      return { port: p2 };
+    }
+    const p = parseInt(raw, 10);
+    return Number.isFinite(p) && p > 0 ? { port: p } : { port: null, reason: "invalid" };
+  } catch {
+    return discoverAndHeal();
+  }
+}
+async function rpcCall(method, params) {
+  const result = readPort();
+  if (!result.port) {
+    throw new Error(result.reason === "invalid" ? PORT_FILE_INVALID_MSG : PORT_FILE_MISSING_MSG);
+  }
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${result.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 Vorn server: ${err.message}. Is the app running?`));
+    });
+  });
+}
+async function rpcNotify(method, params) {
+  const result = readPort();
+  if (!result.port) {
+    throw new Error(result.reason === "invalid" ? PORT_FILE_INVALID_MSG : PORT_FILE_MISSING_MSG);
+  }
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${result.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 Vorn server: ${err.message}. Is the app running?`));
+    });
+  });
+}
+
+// src/tools/sessions.ts
+var AGENT_TYPES3 = [
+  "claude",
+  "copilot",
+  "codex",
+  "opencode",
+  "gemini"
+];
+function registerSessionTools(server) {
+  server.tool(
+    "list_sessions",
+    'List terminal sessions. Filter by status: "active" (running terminals), "recent" (past sessions), or "archived".',
+    {
+      filter: z4.enum(["active", "recent", "archived"]).optional().describe("Session filter (default: active)"),
+      project_name: V.name.optional().describe("Filter by project name"),
+      project_path: V.absolutePath.optional().describe("Filter by project path (for recent sessions)")
+    },
+    async (args) => {
+      const filter = args.filter ?? "active";
+      try {
+        if (filter === "active") {
+          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) }] };
+        } else if (filter === "recent") {
+          const sessions = await rpcCall("sessions:getRecent", args.project_path);
+          return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
+        } else {
+          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_session",
+    "Launch an AI agent session (interactive terminal or headless). Requires the Vorn 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"),
+      headless: z4.boolean().optional().describe("Launch as headless (no UI) 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 }
+      };
+      const rpcMethod = args.headless ? "headless:create" : "terminal:create";
+      const label = args.headless ? "headless" : "terminal";
+      try {
+        const session = await rpcCall(rpcMethod, 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 ${label} agent: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "kill_session",
+    "Kill a terminal or headless session. Requires the Vorn app to be running.",
+    {
+      id: V.id.describe("Session ID to kill"),
+      headless: z4.boolean().optional().describe("Kill a headless session instead of a terminal")
+    },
+    async (args) => {
+      const rpcMethod = args.headless ? "headless:kill" : "terminal:kill";
+      const label = args.headless ? "headless session" : "session";
+      try {
+        await rpcCall(rpcMethod, args.id);
+        return { content: [{ type: "text", text: `Killed ${label}: ${args.id}` }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error killing ${label}: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "rename_session",
+    "Rename a terminal session. Changes the display name shown in the UI.",
+    {
+      id: V.id.describe("Session ID"),
+      display_name: V.shortText.describe("New display name")
+    },
+    async (args) => {
+      try {
+        await rpcCall("terminal:rename", { id: args.id, displayName: args.display_name });
+        return {
+          content: [{ type: "text", text: `Renamed session ${args.id} to "${args.display_name}"` }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error renaming session: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "reorder_sessions",
+    "Reorder terminal sessions in the grid. Provide session IDs in the desired display order.",
+    {
+      session_ids: z4.array(V.id).min(1, "At least one session ID is required").describe("Session IDs in desired order")
+    },
+    async (args) => {
+      try {
+        await rpcCall("terminal:reorder", args.session_ids);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Reordered ${args.session_ids.length} sessions`
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error reordering sessions: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "read_session_output",
+    "Read terminal output from a running session. Output is stored in a rolling 1000-line buffer with ANSI codes stripped.",
+    {
+      id: V.id.describe("Session ID"),
+      lines: z4.number().int().min(1).max(1e3).optional().describe("Number of lines to read from the end (default: all)")
+    },
+    async (args) => {
+      try {
+        const output = await rpcCall("terminal:readOutput", {
+          id: args.id,
+          lines: args.lines
+        });
+        return {
+          content: [{ type: "text", text: output.join("\n") }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error reading session output: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "write_to_terminal",
+    "Send input to a running terminal session. Requires the Vorn 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)"),
+      raw: z4.boolean().optional().describe("Send data as-is without appending carriage return (for raw terminal control)")
+    },
+    async (args) => {
+      try {
+        const data = args.raw ? args.data : args.data.replace(/[\r\n]+$/, "") + "\r";
+        await rpcNotify("terminal:write", { id: args.id, data });
+        return { content: [{ type: "text", text: `Wrote to session: ${args.id}` }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error writing to terminal: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  const KEY_MAP = {
+    enter: "\r",
+    escape: "\x1B",
+    esc: "\x1B",
+    tab: "	",
+    "shift+tab": "\x1B[Z",
+    up: "\x1B[A",
+    down: "\x1B[B",
+    left: "\x1B[D",
+    right: "\x1B[C",
+    backspace: "\x7F",
+    delete: "\x1B[3~",
+    home: "\x1B[H",
+    end: "\x1B[F",
+    "ctrl+c": "",
+    "ctrl+d": "",
+    "ctrl+x": "",
+    "ctrl+z": ""
+  };
+  server.tool(
+    "send_key",
+    "Send a single keystroke or key combo to a terminal session without appending Enter. Use for TUI interactions like selecting menu options (1, 2, y, n), pressing Escape, Ctrl+C, arrow keys, etc.",
+    {
+      id: V.id.describe("Session ID"),
+      key: z4.string().min(1).max(20).describe(
+        "Key to send: single char (1, y, n), named key (enter, escape, tab, up, down, left, right, backspace, delete, home, end), or combo (ctrl+c, ctrl+d, ctrl+x, ctrl+z, shift+tab)"
+      )
+    },
+    async (args) => {
+      const key = args.key.toLowerCase().trim();
+      let data = KEY_MAP[key];
+      if (!data) {
+        const ctrlMatch = key.match(/^ctrl\+([a-z])$/);
+        if (ctrlMatch) {
+          data = String.fromCharCode(ctrlMatch[1].toUpperCase().charCodeAt(0) - 64);
+        } else if (args.key.length === 1) {
+          data = args.key;
+        } else {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unknown key: "${args.key}". Supported: single chars (1, y, n), named keys (${Object.keys(KEY_MAP).join(", ")}), or ctrl+<letter>.`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      try {
+        await rpcNotify("terminal:write", { id: args.id, data });
+        return {
+          content: [{ type: "text", text: `Sent key "${args.key}" to session: ${args.id}` }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error sending key to terminal: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_session_events",
+    "List session lifecycle events (created, exited, task_linked, renamed, archived, unarchived). Use for post-mortem analysis and multi-agent coordination.",
+    {
+      session_id: V.id.optional().describe("Filter by session ID"),
+      event_type: z4.enum(["created", "exited", "task_linked", "renamed", "archived", "unarchived"]).optional().describe("Filter by event type"),
+      limit: z4.number().int().min(1).max(200).optional().describe("Max events to return (default: 50)")
+    },
+    async (args) => {
+      try {
+        let events;
+        if (args.session_id) {
+          events = await rpcCall("sessionEvent:listBySession", {
+            sessionId: args.session_id,
+            limit: args.limit ?? 50
+          });
+        } else {
+          events = await rpcCall("sessionEvent:list", {
+            eventType: args.event_type,
+            limit: args.limit ?? 50
+          });
+        }
+        return { content: [{ type: "text", text: JSON.stringify(events, null, 2) }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error listing session events: ${err instanceof Error ? err.message : err}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/workflows.ts
+import crypto2 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: 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,
+    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 = crypto2.randomUUID();
+    nodes.push({
+      id: nodeId,
+      type: "launchAgent",
+      label: `Launch ${action.agentType}`,
+      config: action,
+      position: { x: 0, y: (i + 1) * NODE_GAP }
+    });
+    edges.push({
+      id: crypto2.randomUUID(),
+      source: prevId,
+      target: nodeId
+    });
+    prevId = nodeId;
+  }
+  return { nodes, edges };
+}
+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).",
+    {
+      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: crypto2.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);
+      dbSignalChange();
+      return { content: [{ type: "text", text: JSON.stringify(workflow, null, 2) }] };
+    }
+  );
+  server.tool(
+    "update_workflow",
+    "Update a workflow's properties",
+    {
+      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);
+      dbSignalChange();
+      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);
+      dbSignalChange();
+      return { content: [{ type: "text", text: `Deleted workflow: ${workflow.name}` }] };
+    }
+  );
+  server.tool(
+    "list_workflow_runs",
+    "List workflow execution history. Filter by workflow_id or task_id.",
+    {
+      workflow_id: V.id.optional().describe("Filter by workflow ID"),
+      task_id: V.id.optional().describe("Filter by task ID (runs triggered by this task)"),
+      limit: z5.number().int().min(1).max(100).optional().describe("Max results (default: 20)")
+    },
+    async (args) => {
+      if (args.workflow_id && args.task_id) {
+        return {
+          content: [{ type: "text", text: "Error: provide workflow_id or task_id, not both" }],
+          isError: true
+        };
+      }
+      if (args.task_id) {
+        const runs = listWorkflowRunsByTask(args.task_id, args.limit ?? 20);
+        return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
+      }
+      if (args.workflow_id) {
+        const runs = listWorkflowRuns(args.workflow_id, args.limit ?? 20);
+        return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
+      }
+      return {
+        content: [{ type: "text", text: "Error: provide either workflow_id or task_id" }],
+        isError: true
+      };
+    }
+  );
+  server.tool(
+    "get_workflow_schedule",
+    "Get scheduler info for a workflow: execution log or next scheduled run. Requires the Vorn app to be running.",
+    {
+      workflow_id: V.id.optional().describe("Workflow ID (required for next_run, optional for log)"),
+      info: z5.enum(["log", "next_run"]).optional().describe("What to retrieve (default: log)")
+    },
+    async (args) => {
+      const info = args.info ?? "log";
+      try {
+        if (info === "next_run") {
+          if (!args.workflow_id) {
+            return {
+              content: [{ type: "text", text: "Error: workflow_id is required for next_run" }],
+              isError: true
+            };
+          }
+          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)"
+              }
+            ]
+          };
+        } else {
+          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
+        };
+      }
+    }
+  );
+}
+
+// src/tools/config.ts
+function registerConfigTools(server) {
+  server.tool(
+    "get_config",
+    "Get the full Vorn configuration (projects, tasks, workflows, settings)",
+    async () => {
+      const config = configManager.loadConfig();
+      return { content: [{ type: "text", text: JSON.stringify(config, null, 2) }] };
+    }
+  );
+}
+
+// src/tools/workspaces.ts
+import crypto3 from "crypto";
+import { z as z6 } 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: crypto3.randomUUID(),
+        name: args.name,
+        order: maxOrder + 1,
+        ...args.icon && { icon: args.icon },
+        ...args.icon_color && { iconColor: args.icon_color }
+      };
+      dbInsertWorkspace(workspace);
+      dbSignalChange();
+      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: z6.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);
+      dbSignalChange();
+      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);
+      dbSignalChange();
+      return { content: [{ type: "text", text: `Deleted workspace: ${workspace.name}` }] };
+    }
+  );
+}
+
+// src/server.ts
+function createMcpServer(version) {
+  const server = new McpServer({ name: "vorn", version }, { capabilities: { tools: {} } });
+  registerConfigTools(server);
+  registerProjectTools(server);
+  registerTaskTools(server);
+  registerSessionTools(server);
+  registerWorkflowTools(server);
+  registerWorkspaceTools(server);
+  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 version = true ? "0.1.0" : createRequire(import.meta.url)("../package.json").version;
+  const server = createMcpServer(version);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  transport.onclose = () => {
+    configManager.close();
+    process.exit(0);
+  };
+}
+main().catch((err) => {
+  console.error("Failed to start MCP server:", err);
+  process.exit(1);
+});