@basegrid_tech/mcp 0.6.5

package/dist/index.js

@@ -0,0 +1,3461 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "module";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../server/src/config-manager.ts
+import fs4 from "fs";
+
+// ../shared/src/types.ts
+var CLAUDE_DEFAULT_MODEL_ID = "claude-sonnet-4-6";
+var CLAUDE_DEFAULT_EFFORT = "medium";
+var CODEX_DEFAULT_MODEL_ID = "gpt-5.5";
+var CODEX_OBSOLETE_MODEL_IDS = [
+  "gpt-5-codex",
+  "gpt-5.4-mini",
+  "gpt-5.2"
+];
+var CODEX_DEFAULT_EFFORT = "medium";
+var DEFAULT_WORKSPACE = {
+  id: "personal",
+  name: "Personal",
+  icon: "User",
+  iconColor: "#6b7280",
+  order: 0
+};
+
+// ../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 path3 from "path";
+import fs3 from "fs";
+import { randomUUID } from "crypto";
+
+// ../server/src/logger.ts
+import pino from "pino";
+var log = pino({ level: process.env.VITEST ? "silent" : "info" }, process.stderr);
+var logger_default = log;
+
+// ../server/src/basegrid-paths-fs.ts
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+// ../shared/src/basegrid-paths.ts
+var BASEGRID_DIR_NAME = ".basegrid";
+var ATTACHMENTS_DIR_NAME = "attachments";
+var LEGACY_ATTACHMENTS_DIR_NAME = "chat-attachments";
+var WORKTREES_DIR_NAME = "worktrees";
+var LEGACY_WORKTREES_MARKER = ".basegrid-worktrees";
+var ATTACHMENT_MARKERS = [
+  `/${BASEGRID_DIR_NAME}/${ATTACHMENTS_DIR_NAME}/`,
+  `\\${BASEGRID_DIR_NAME}\\${ATTACHMENTS_DIR_NAME}\\`,
+  `/${BASEGRID_DIR_NAME}/${LEGACY_ATTACHMENTS_DIR_NAME}/`,
+  `\\${BASEGRID_DIR_NAME}\\${LEGACY_ATTACHMENTS_DIR_NAME}\\`
+];
+var MANAGED_WORKTREE_MARKERS = [
+  `/${BASEGRID_DIR_NAME}/${WORKTREES_DIR_NAME}/`,
+  `\\${BASEGRID_DIR_NAME}\\${WORKTREES_DIR_NAME}\\`,
+  `/${LEGACY_WORKTREES_MARKER}/`,
+  `\\${LEGACY_WORKTREES_MARKER}\\`
+];
+
+// ../server/src/basegrid-paths-fs.ts
+function getDataDir() {
+  return path.join(os.homedir(), BASEGRID_DIR_NAME);
+}
+function getDbPath() {
+  return path.join(getDataDir(), "basegrid.db");
+}
+
+// ../server/src/process-utils.ts
+import { execFileSync, execFile } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+function getUserShellEnv() {
+  if (process.platform === "win32") return { ...process.env };
+  try {
+    const shell = process.env.SHELL || "/bin/zsh";
+    const output = execFileSync(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();
+var DEFAULT_NO_PROXY_HOSTS = [
+  "localhost",
+  "127.0.0.1",
+  "::1",
+  ".local",
+  ".ts.net",
+  "10.",
+  "192.168."
+];
+var DEFAULT_NO_PROXY = DEFAULT_NO_PROXY_HOSTS.join(",");
+
+// ../server/src/default-workflows.ts
+var DEFAULT_TASK_WORKFLOW_ID = "system:default-task-workflow";
+function buildDefaultTaskWorkflow() {
+  const triggerConfig = {
+    triggerType: "taskStatusChanged",
+    fromStatus: "todo",
+    toStatus: "in_progress"
+    // projectFilter omitted → fires in every project
+  };
+  const launchConfig = {
+    agentType: "fromTask",
+    projectName: "",
+    projectPath: "",
+    headless: true
+  };
+  return {
+    id: DEFAULT_TASK_WORKFLOW_ID,
+    name: "Default Task Workflow",
+    icon: "Play",
+    iconColor: "#10b981",
+    enabled: true,
+    workspaceId: "personal",
+    nodes: [
+      {
+        id: "trigger-1",
+        type: "trigger",
+        label: "When task moves to In Progress",
+        position: { x: 0, y: 0 },
+        config: triggerConfig
+      },
+      {
+        id: "launch-1",
+        type: "launchAgent",
+        label: "Launch task agent",
+        position: { x: 0, y: 120 },
+        config: launchConfig
+      }
+    ],
+    edges: [{ id: "e1", source: "trigger-1", target: "launch-1" }]
+  };
+}
+
+// ../server/src/database.ts
+var CONFIG_DIR = getDataDir();
+var DB_PATH = getDbPath();
+var db = null;
+function getDb() {
+  if (!db) throw new Error("Database not initialized. Call initDatabase() first.");
+  return db;
+}
+function initDatabase() {
+  if (!fs3.existsSync(CONFIG_DIR)) {
+    fs3.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  try {
+    db = new Database(DB_PATH);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    createSchema();
+    seedSystemDefaults();
+  } 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 seedSystemDefaults() {
+  const d = getDb();
+  const flagRow = d.prepare("SELECT value FROM defaults WHERE key = 'hasSeededDefaultTaskWorkflow'").get();
+  if (flagRow) {
+    try {
+      if (JSON.parse(flagRow.value) === true) return;
+    } catch {
+    }
+  }
+  const existing = d.prepare("SELECT id FROM workflows WHERE id = ?").get(DEFAULT_TASK_WORKFLOW_ID);
+  if (!existing) {
+    const w = buildDefaultTaskWorkflow();
+    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).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"
+    );
+    logger_default.info(`[database] Seeded default task workflow (${DEFAULT_TASK_WORKFLOW_ID})`);
+  }
+  d.prepare(
+    "INSERT OR REPLACE INTO defaults (key, value) VALUES ('hasSeededDefaultTaskWorkflow', ?)"
+  ).run(JSON.stringify(true));
+}
+function recoverCorruptDatabase() {
+  try {
+    db?.close();
+  } catch {
+  }
+  db = null;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${DB_PATH}.corrupt-${timestamp}`;
+  try {
+    if (fs3.existsSync(DB_PATH)) {
+      fs3.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 (fs3.existsSync(file)) fs3.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();
+    seedSystemDefaults();
+    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 = path3.join(CONFIG_DIR, ".db-signal");
+    fs3.writeFileSync(signalPath, Date.now().toString());
+  } catch {
+  }
+}
+function closeDatabase() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+function factoryResetDatabase() {
+  if (!db) initDatabase();
+  const d = getDb();
+  try {
+    d.pragma("wal_checkpoint(TRUNCATE)");
+  } catch {
+  }
+  const run = d.transaction(() => {
+    const rows = d.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+    d.pragma("foreign_keys = OFF");
+    for (const { name } of rows) {
+      try {
+        d.exec(`DROP TABLE IF EXISTS "${name}"`);
+      } catch (err) {
+        logger_default.warn(`[database] factory-reset: drop ${name} failed: ${err.message}`);
+      }
+    }
+    d.pragma("foreign_keys = ON");
+  });
+  run();
+  createSchema();
+  seedSystemDefaults();
+  closeDatabase();
+  for (const f of [DB_PATH, `${DB_PATH}-wal`, `${DB_PATH}-shm`, `${DB_PATH}-journal`]) {
+    try {
+      if (fs3.existsSync(f)) fs3.rmSync(f, { force: true });
+    } catch (err) {
+      logger_default.warn(`[database] factory-reset: rm ${f} failed: ${err.message}`);
+    }
+  }
+  initDatabase();
+}
+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 basegrid_script_statuses (
+      id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      worktree_path TEXT,
+      role TEXT NOT NULL,
+      command TEXT NOT NULL,
+      phase TEXT NOT NULL,
+      exit_code INTEGER,
+      started_at INTEGER NOT NULL,
+      finished_at INTEGER,
+      terminal_id TEXT,
+      output TEXT,
+      error TEXT,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_basegrid_script_statuses_project
+      ON basegrid_script_statuses(project_path);
+
+    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,
+      project_id TEXT
+    );
+    -- UNIQUE INDEX \u043F\u043E project_id \u0441\u043E\u0437\u0434\u0430\u0451\u0442\u0441\u044F \u0432 \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u0438 v17 (\u0441\u043C. migrateSchema):
+    -- \u043D\u0430 upgrade-\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0438 \u043A\u043E\u043B\u043E\u043D\u043A\u0438 project_id \u0435\u0449\u0451 \u043D\u0435\u0442, \u0438 CREATE INDEX \u0437\u0434\u0435\u0441\u044C \u043F\u0430\u0434\u0430\u043B \u0431\u044B.
+
+    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 account (
+      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+      user_id TEXT NOT NULL,
+      email TEXT NOT NULL,
+      plan TEXT NOT NULL DEFAULT 'free',
+      plan_expires_at TEXT,
+      encrypted_access_token TEXT NOT NULL,
+      encrypted_refresh_token TEXT NOT NULL,
+      token_expires_at INTEGER NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS install_meta (
+      key TEXT PRIMARY KEY,
+      value 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,
+      agent_session_id TEXT,
+      docked INTEGER NOT NULL DEFAULT 0,
+      basegrid_role TEXT,
+      shell_cwd 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 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,
+      agent_type TEXT,
+      project_name TEXT,
+      project_path TEXT,
+      approved_at 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);
+
+    CREATE TABLE IF NOT EXISTS session_activity (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      terminal_id TEXT NOT NULL,
+      agent_session_id TEXT,
+      seq INTEGER NOT NULL,
+      kind TEXT NOT NULL,
+      timestamp INTEGER NOT NULL,
+      tool_name TEXT,
+      tool_use_id TEXT,
+      parent_tool_use_id TEXT,
+      summary TEXT,
+      status TEXT,
+      detail_json TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_activity_agent
+      ON session_activity(agent_session_id, id);
+    CREATE INDEX IF NOT EXISTS idx_session_activity_terminal
+      ON session_activity(terminal_id, id);
+
+    CREATE TABLE IF NOT EXISTS worktree_diff_cache (
+      worktree_path TEXT PRIMARY KEY,
+      insertions    INTEGER NOT NULL,
+      deletions     INTEGER NOT NULL,
+      files_changed INTEGER NOT NULL,
+      updated_at    INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS worktree_list_cache (
+      project_path        TEXT NOT NULL,
+      worktree_path       TEXT NOT NULL,
+      branch              TEXT,
+      is_main             INTEGER NOT NULL,
+      name                TEXT,
+      alias               TEXT,
+      alias_generated_at  INTEGER,
+      sort_order          INTEGER NOT NULL DEFAULT 0,
+      updated_at          INTEGER NOT NULL,
+      PRIMARY KEY (project_path, worktree_path)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_worktree_list_project
+      ON worktree_list_cache(project_path);
+
+    CREATE TABLE IF NOT EXISTS usage_metrics (
+      id                      INTEGER PRIMARY KEY AUTOINCREMENT,
+      terminal_id             TEXT NOT NULL,
+      agent_session_id        TEXT,
+      project_path            TEXT,
+      timestamp               INTEGER NOT NULL,
+      model                   TEXT,
+      input_tokens            INTEGER NOT NULL,
+      output_tokens           INTEGER NOT NULL,
+      cache_creation_tokens   INTEGER NOT NULL,
+      cache_read_tokens       INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_usage_metrics_agent
+      ON usage_metrics(agent_session_id, timestamp);
+    CREATE INDEX IF NOT EXISTS idx_usage_metrics_project
+      ON usage_metrics(project_path, timestamp);
+    CREATE INDEX IF NOT EXISTS idx_usage_metrics_ts
+      ON usage_metrics(timestamp);
+  `);
+  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") && !sessionCols.some((c) => c.name === "agent_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)");
+  }
+  if (version < 7) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      const hasOld = sessionCols.some((c) => c.name === "claude_session_id");
+      const hasNew = sessionCols.some((c) => c.name === "agent_session_id");
+      if (hasOld && !hasNew) {
+        try {
+          d.exec("ALTER TABLE sessions RENAME COLUMN claude_session_id TO agent_session_id");
+        } catch {
+          d.exec("ALTER TABLE sessions ADD COLUMN agent_session_id TEXT");
+          d.exec("UPDATE sessions SET agent_session_id = claude_session_id");
+        }
+      } else if (hasOld && hasNew) {
+        d.exec(
+          "UPDATE sessions SET agent_session_id = claude_session_id WHERE agent_session_id IS NULL AND claude_session_id IS NOT NULL"
+        );
+      } else if (!hasNew) {
+        d.exec("ALTER TABLE sessions ADD COLUMN agent_session_id TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '7')"
+      ).run();
+    })();
+    logger_default.info(
+      "[database] migrated schema to version 7 (rename claude_session_id \u2192 agent_session_id)"
+    );
+  }
+  if (version < 8) {
+    d.transaction(() => {
+      const cols = d.prepare("PRAGMA table_info(workflow_run_nodes)").all();
+      if (!cols.some((c) => c.name === "approved_at")) {
+        d.exec("ALTER TABLE workflow_run_nodes ADD COLUMN approved_at TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '8')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 8 (approval gate timestamp)");
+  }
+  if (version < 9) {
+    d.transaction(() => {
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS session_activity (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          terminal_id TEXT NOT NULL,
+          agent_session_id TEXT,
+          seq INTEGER NOT NULL,
+          kind TEXT NOT NULL,
+          timestamp INTEGER NOT NULL,
+          tool_name TEXT,
+          tool_use_id TEXT,
+          summary TEXT,
+          status TEXT,
+          detail_json TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_activity_agent
+          ON session_activity(agent_session_id, id);
+        CREATE INDEX IF NOT EXISTS idx_session_activity_terminal
+          ON session_activity(terminal_id, id);
+      `);
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '9')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 9 (session_activity)");
+  }
+  if (version < 10) {
+    d.transaction(() => {
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS worktree_diff_cache (
+          worktree_path TEXT PRIMARY KEY,
+          insertions    INTEGER NOT NULL,
+          deletions     INTEGER NOT NULL,
+          files_changed INTEGER NOT NULL,
+          updated_at    INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS worktree_list_cache (
+          project_path  TEXT NOT NULL,
+          worktree_path TEXT NOT NULL,
+          branch        TEXT,
+          is_main       INTEGER NOT NULL,
+          name          TEXT,
+          updated_at    INTEGER NOT NULL,
+          PRIMARY KEY (project_path, worktree_path)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_worktree_list_project
+          ON worktree_list_cache(project_path);
+      `);
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '10')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 10 (worktree caches)");
+  }
+  if (version < 11) {
+    d.transaction(() => {
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS usage_metrics (
+          id                      INTEGER PRIMARY KEY AUTOINCREMENT,
+          terminal_id             TEXT NOT NULL,
+          agent_session_id        TEXT,
+          project_path            TEXT,
+          timestamp               INTEGER NOT NULL,
+          model                   TEXT,
+          input_tokens            INTEGER NOT NULL,
+          output_tokens           INTEGER NOT NULL,
+          cache_creation_tokens   INTEGER NOT NULL,
+          cache_read_tokens       INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_usage_metrics_agent
+          ON usage_metrics(agent_session_id, timestamp);
+        CREATE INDEX IF NOT EXISTS idx_usage_metrics_project
+          ON usage_metrics(project_path, timestamp);
+        CREATE INDEX IF NOT EXISTS idx_usage_metrics_ts
+          ON usage_metrics(timestamp);
+      `);
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '11')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 11 (usage_metrics)");
+  }
+  if (version < 12) {
+    d.transaction(() => {
+      const sessionCols = d.prepare("PRAGMA table_info(sessions)").all();
+      if (!sessionCols.some((c) => c.name === "docked")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN docked INTEGER NOT NULL DEFAULT 0");
+      }
+      if (!sessionCols.some((c) => c.name === "basegrid_role")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN basegrid_role TEXT");
+      }
+      if (!sessionCols.some((c) => c.name === "shell_cwd")) {
+        d.exec("ALTER TABLE sessions ADD COLUMN shell_cwd TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '12')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 12 (docked terminals + basegrid roles)");
+  }
+  if (version < 13) {
+    d.transaction(() => {
+      const result = d.prepare("DELETE FROM sessions WHERE agent_type = 'shell'").run();
+      if (result.changes > 0) {
+        logger_default.info(`[database] migration v13: removed ${result.changes} stale shell session(s)`);
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '13')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 13 (purge shell zombies)");
+  }
+  if (version < 14) {
+    d.transaction(() => {
+      const cols = d.prepare("PRAGMA table_info(session_activity)").all();
+      if (!cols.some((c) => c.name === "parent_tool_use_id")) {
+        d.exec("ALTER TABLE session_activity ADD COLUMN parent_tool_use_id TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '14')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 14 (parent_tool_use_id for subagent nesting)");
+  }
+  if (version < 15) {
+    d.transaction(() => {
+      const cols = d.prepare("PRAGMA table_info(worktree_list_cache)").all();
+      if (!cols.some((c) => c.name === "alias")) {
+        d.exec("ALTER TABLE worktree_list_cache ADD COLUMN alias TEXT");
+      }
+      if (!cols.some((c) => c.name === "alias_generated_at")) {
+        d.exec("ALTER TABLE worktree_list_cache ADD COLUMN alias_generated_at INTEGER");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '15')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 15 (worktree alias from LLM)");
+  }
+  if (version < 16) {
+    d.transaction(() => {
+      const cols = d.prepare("PRAGMA table_info(worktree_list_cache)").all();
+      if (!cols.some((c) => c.name === "sort_order")) {
+        d.exec("ALTER TABLE worktree_list_cache ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0");
+      }
+      const projects = d.prepare("SELECT DISTINCT project_path FROM worktree_list_cache").all();
+      const updateOrder = d.prepare(
+        "UPDATE worktree_list_cache SET sort_order = ? WHERE project_path = ? AND worktree_path = ?"
+      );
+      for (const { project_path } of projects) {
+        const rows = d.prepare(
+          "SELECT worktree_path FROM worktree_list_cache WHERE project_path = ? ORDER BY is_main DESC, name ASC"
+        ).all(project_path);
+        rows.forEach((r, i) => updateOrder.run(i + 1, project_path, r.worktree_path));
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '16')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 16 (worktree sort_order)");
+  }
+  if (version < 17) {
+    d.transaction(() => {
+      const cols = d.prepare("PRAGMA table_info(projects)").all();
+      if (!cols.some((c) => c.name === "project_id")) {
+        d.exec("ALTER TABLE projects ADD COLUMN project_id TEXT");
+      }
+      const rows = d.prepare("SELECT name FROM projects WHERE project_id IS NULL OR project_id = ''").all();
+      const upd = d.prepare("UPDATE projects SET project_id = ? WHERE name = ?");
+      for (const r of rows) {
+        const id = randomUUID();
+        upd.run(id, r.name);
+      }
+      d.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_projects_project_id ON projects(project_id)");
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '17')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 17 (projects.project_id UUID)");
+  }
+  if (version < 18) {
+    d.transaction(() => {
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS source_connections (
+          id TEXT PRIMARY KEY,
+          connector_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          filters TEXT NOT NULL DEFAULT '{}',
+          sync_interval_minutes INTEGER NOT NULL DEFAULT 5,
+          status_mapping TEXT NOT NULL DEFAULT '{}',
+          execution_project TEXT,
+          last_sync_at TEXT,
+          last_sync_error TEXT,
+          sync_cursor TEXT,
+          created_at TEXT NOT NULL
+        )
+      `);
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS task_source_links (
+          task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+          connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+          connector_id TEXT NOT NULL,
+          external_id TEXT NOT NULL,
+          external_url TEXT NOT NULL,
+          source_status_raw TEXT NOT NULL,
+          source_updated_at TEXT NOT NULL,
+          last_synced_at TEXT NOT NULL,
+          conflict_state TEXT NOT NULL DEFAULT 'none',
+          PRIMARY KEY (task_id),
+          UNIQUE (connection_id, external_id)
+        )
+      `);
+      const taskCols = d.prepare("PRAGMA table_info(tasks)").all();
+      if (!taskCols.some((c) => c.name === "source_connector_id")) {
+        d.exec("ALTER TABLE tasks ADD COLUMN source_connector_id TEXT");
+      }
+      if (!taskCols.some((c) => c.name === "source_external_url")) {
+        d.exec("ALTER TABLE tasks ADD COLUMN source_external_url TEXT");
+      }
+      if (!taskCols.some((c) => c.name === "source_external_id")) {
+        d.exec("ALTER TABLE tasks ADD COLUMN source_external_id TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '18')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 18 (connector source connections)");
+  }
+  if (version < 19) {
+    d.transaction(() => {
+      const result = d.prepare("DELETE FROM workflows WHERE id LIKE 'connector:%'").run();
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '19')"
+      ).run();
+      logger_default.info(
+        `[database] migrated schema to version 19 (removed ${result.changes} seeded connector workflow(s))`
+      );
+    })();
+  }
+  if (version < 20) {
+    d.transaction(() => {
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS sync_history (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+          kind TEXT NOT NULL,
+          started_at TEXT NOT NULL,
+          finished_at TEXT NOT NULL,
+          duration_ms INTEGER NOT NULL,
+          imported INTEGER NOT NULL DEFAULT 0,
+          updated INTEGER NOT NULL DEFAULT 0,
+          status TEXT NOT NULL,
+          error_message TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_sync_history_conn
+          ON sync_history(connection_id, id DESC);
+      `);
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '20')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 20 (sync_history)");
+  }
+  if (version < 21) {
+    d.transaction(() => {
+      const tasks = d.prepare(
+        `SELECT t.id, t.source_connector_id, t.source_external_id, t.source_external_url, t.updated_at
+           FROM tasks t
+           LEFT JOIN task_source_links l ON l.task_id = t.id
+           WHERE t.source_connector_id IS NOT NULL
+             AND t.source_external_id IS NOT NULL
+             AND l.task_id IS NULL`
+      ).all();
+      const insertLink = d.prepare(
+        `INSERT OR IGNORE INTO task_source_links
+         (task_id, connection_id, connector_id, external_id, external_url, source_status_raw, source_updated_at, last_synced_at, conflict_state)
+         VALUES (?, ?, ?, ?, ?, '', ?, ?, 'none')`
+      );
+      let restored = 0;
+      for (const t of tasks) {
+        const conn = d.prepare(
+          "SELECT id FROM source_connections WHERE connector_id = ? ORDER BY created_at DESC LIMIT 1"
+        ).get(t.source_connector_id);
+        if (!conn) continue;
+        insertLink.run(
+          t.id,
+          conn.id,
+          t.source_connector_id,
+          t.source_external_id,
+          t.source_external_url ?? "",
+          t.updated_at,
+          t.updated_at
+        );
+        restored++;
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '21')"
+      ).run();
+      logger_default.info(`[database] migrated schema to version 21 (restored ${restored} task_source_links)`);
+    })();
+  }
+  if (version < 22) {
+    d.transaction(() => {
+      const cols = d.prepare("PRAGMA table_info(task_source_links)").all();
+      if (!cols.some((c) => c.name === "last_error")) {
+        d.exec("ALTER TABLE task_source_links ADD COLUMN last_error TEXT");
+      }
+      if (!cols.some((c) => c.name === "last_error_at")) {
+        d.exec("ALTER TABLE task_source_links ADD COLUMN last_error_at TEXT");
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '22')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 22 (task_source_links.last_error)");
+  }
+  if (version < 23) {
+    d.transaction(() => {
+      const result = d.prepare(
+        "UPDATE source_connections SET sync_interval_minutes = 30 WHERE sync_interval_minutes < 30"
+      ).run();
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '23')"
+      ).run();
+      logger_default.info(
+        `[database] migrated schema to version 23 (raised ${result.changes} connection(s) to 30min sync interval)`
+      );
+    })();
+  }
+  if (version < 24) {
+    d.transaction(() => {
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS account (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          user_id TEXT NOT NULL,
+          email TEXT NOT NULL,
+          plan TEXT NOT NULL DEFAULT 'free',
+          plan_expires_at TEXT,
+          encrypted_access_token TEXT NOT NULL,
+          encrypted_refresh_token TEXT NOT NULL,
+          token_expires_at INTEGER NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `);
+      d.exec(`
+        CREATE TABLE IF NOT EXISTS install_meta (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        )
+      `);
+      const existing = d.prepare("SELECT value FROM install_meta WHERE key = 'install_id'").get();
+      if (!existing) {
+        d.prepare("INSERT INTO install_meta (key, value) VALUES ('install_id', ?)").run(
+          randomUUID()
+        );
+      }
+      d.prepare(
+        "INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', '24')"
+      ).run();
+    })();
+    logger_default.info("[database] migrated schema to version 24 (account cache + install_id)");
+  }
+}
+function verifySchema(d) {
+  const expectedTables = [
+    {
+      name: "source_connections",
+      ddl: `CREATE TABLE IF NOT EXISTS source_connections (
+        id TEXT PRIMARY KEY,
+        connector_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        filters TEXT NOT NULL DEFAULT '{}',
+        sync_interval_minutes INTEGER NOT NULL DEFAULT 30,
+        status_mapping TEXT NOT NULL DEFAULT '{}',
+        execution_project TEXT,
+        last_sync_at TEXT,
+        last_sync_error TEXT,
+        sync_cursor TEXT,
+        created_at TEXT NOT NULL
+      )`
+    },
+    {
+      name: "sync_history",
+      ddl: `CREATE TABLE IF NOT EXISTS sync_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+        kind TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        finished_at TEXT NOT NULL,
+        duration_ms INTEGER NOT NULL,
+        imported INTEGER NOT NULL DEFAULT 0,
+        updated INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL,
+        error_message TEXT
+      )`
+    },
+    {
+      name: "task_source_links",
+      ddl: `CREATE TABLE IF NOT EXISTS task_source_links (
+        task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+        connection_id TEXT NOT NULL REFERENCES source_connections(id) ON DELETE CASCADE,
+        connector_id TEXT NOT NULL,
+        external_id TEXT NOT NULL,
+        external_url TEXT NOT NULL,
+        source_status_raw TEXT NOT NULL,
+        source_updated_at TEXT NOT NULL,
+        last_synced_at TEXT NOT NULL,
+        conflict_state TEXT NOT NULL DEFAULT 'none',
+        PRIMARY KEY (task_id),
+        UNIQUE (connection_id, external_id)
+      )`
+    }
+  ];
+  for (const { name, ddl } of expectedTables) {
+    const row = d.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name);
+    if (row) continue;
+    try {
+      d.exec(ddl);
+      logger_default.warn(`[database] self-heal: created missing table ${name}`);
+    } catch (err) {
+      logger_default.error(`[database] self-heal: failed to create table ${name}:`, err);
+    }
+  }
+  const expectedByTable = {
+    projects: [
+      {
+        column: "workspace_id",
+        ddl: "ALTER TABLE projects ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'personal'"
+      },
+      {
+        column: "project_id",
+        ddl: "ALTER TABLE projects ADD COLUMN project_id TEXT"
+      }
+    ],
+    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: "agent_session_id", ddl: "ALTER TABLE sessions ADD COLUMN agent_session_id TEXT" },
+      {
+        column: "docked",
+        ddl: "ALTER TABLE sessions ADD COLUMN docked INTEGER NOT NULL DEFAULT 0"
+      },
+      { column: "basegrid_role", ddl: "ALTER TABLE sessions ADD COLUMN basegrid_role TEXT" },
+      { column: "shell_cwd", ddl: "ALTER TABLE sessions ADD COLUMN shell_cwd TEXT" }
+    ],
+    agent_commands: [
+      {
+        column: "headless_args",
+        ddl: "ALTER TABLE agent_commands ADD COLUMN headless_args TEXT"
+      }
+    ],
+    workflow_run_nodes: [
+      { column: "agent_type", ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN agent_type TEXT" },
+      {
+        column: "project_name",
+        ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN project_name TEXT"
+      },
+      {
+        column: "project_path",
+        ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN project_path TEXT"
+      },
+      { column: "approved_at", ddl: "ALTER TABLE workflow_run_nodes ADD COLUMN approved_at TEXT" }
+    ],
+    tasks: [
+      {
+        column: "source_connector_id",
+        ddl: "ALTER TABLE tasks ADD COLUMN source_connector_id TEXT"
+      },
+      {
+        column: "source_external_url",
+        ddl: "ALTER TABLE tasks ADD COLUMN source_external_url TEXT"
+      },
+      {
+        column: "source_external_id",
+        ddl: "ALTER TABLE tasks ADD COLUMN source_external_id TEXT"
+      }
+    ],
+    task_source_links: [
+      {
+        column: "last_error",
+        ddl: "ALTER TABLE task_source_links ADD COLUMN last_error TEXT"
+      },
+      {
+        column: "last_error_at",
+        ddl: "ALTER TABLE task_source_links ADD COLUMN last_error_at TEXT"
+      }
+    ],
+    worktree_list_cache: [
+      { column: "alias", ddl: "ALTER TABLE worktree_list_cache ADD COLUMN alias TEXT" },
+      {
+        column: "alias_generated_at",
+        ddl: "ALTER TABLE worktree_list_cache ADD COLUMN alias_generated_at INTEGER"
+      },
+      {
+        column: "sort_order",
+        ddl: "ALTER TABLE worktree_list_cache ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0"
+      }
+    ]
+  };
+  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, unknownKeys } = 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,
+    ...unknownKeys.length > 0 ? { loadWarnings: { unknownDefaults: unknownKeys } } : {}
+  };
+}
+var DEFAULTS_KEYS_MAP = {
+  shell: true,
+  fontSize: true,
+  theme: true,
+  rowHeight: true,
+  defaultAgent: true,
+  notifications: true,
+  hasSeenOnboarding: true,
+  widgetEnabled: true,
+  minimizeToTray: true,
+  dashboardEnabled: true,
+  slashCommandFallbackDescription: true,
+  taskViewMode: true,
+  taskListCollapsedStatuses: true,
+  layoutMode: true,
+  mainViewMode: true,
+  activeWorkspace: true,
+  updateChannel: true,
+  webAccessEnabled: true,
+  mobileAccessEnabled: true,
+  networkAccessEnabled: true,
+  proxy: true,
+  proxySource: true,
+  showHeadlessAgents: true,
+  headlessRetentionMinutes: true,
+  autoSwitchSuppressSeconds: true,
+  claudeDefaultModel: true,
+  claudeDefaultEffort: true,
+  codexDefaultModel: true,
+  codexDefaultEffort: true,
+  language: true,
+  hasSeededDefaultTaskWorkflow: true,
+  defaultSpinnerVariant: true,
+  dragFilesFromChanges: true,
+  taskGithubIssueEnabled: true,
+  morningBriefingEnabled: true,
+  lastBriefingShownDate: true,
+  toolHeatmapEnabled: true,
+  dashboardCollapsedColumns: true,
+  perfOverlayEnabled: true,
+  sidebarSnapPointsEnabled: true,
+  sidebarWidth: true,
+  navigationHistoryEnabled: true,
+  experimentalClaudeStreamRuntime: true,
+  costForecastEnabled: true,
+  sendAnonymousUsageData: true
+};
+var DEFAULTS_KEYS = Object.keys(DEFAULTS_KEYS_MAP);
+var INTERNAL_DEFAULTS_KEYS = /* @__PURE__ */ new Set([
+  "storageMigrationV1",
+  "storageMigrationV1HealSessions",
+  "lastStorageCleanupAt",
+  "lastStorageCleanupBytes",
+  "ui:activeWorktreePath"
+]);
+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);
+  }
+  const whitelist = new Set(DEFAULTS_KEYS);
+  const result = {};
+  const unknownKeys = [];
+  for (const dbKey of Object.keys(map)) {
+    if (whitelist.has(dbKey)) {
+      result[dbKey] = map[dbKey];
+    } else if (INTERNAL_DEFAULTS_KEYS.has(dbKey)) {
+    } else {
+      unknownKeys.push(dbKey);
+    }
+  }
+  if (unknownKeys.length > 0) {
+    logger_default.warn(
+      `[database] loadDefaults: ${unknownKeys.length} unknown key(s) in defaults table will be ignored: ${unknownKeys.join(", ")}`
+    );
+  }
+  const defaultShell = process.platform === "win32" ? process.env.COMSPEC || "powershell.exe" : process.env.SHELL || "/bin/zsh";
+  return {
+    defaults: {
+      ...result,
+      shell: result.shell ?? defaultShell,
+      fontSize: result.fontSize ?? 12,
+      theme: result.theme ?? "dark"
+    },
+    unknownKeys
+  };
+}
+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));
+      }
+    }
+    const existingIds = /* @__PURE__ */ new Map();
+    for (const r of d.prepare("SELECT name, project_id FROM projects").all()) {
+      if (r.project_id) existingIds.set(r.name, r.project_id);
+    }
+    d.prepare("DELETE FROM projects").run();
+    const insertProject = d.prepare(
+      "INSERT INTO projects (name, path, preferred_agents, icon, icon_color, host_ids, workspace_id, project_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    for (const p of config.projects) {
+      const projectId = p.projectId ?? existingIds.get(p.name) ?? randomUUID();
+      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",
+        projectId
+      );
+    }
+    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, source_connector_id, source_external_url, source_external_id)
+       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,
+        t.sourceConnectorId ?? null,
+        t.sourceExternalUrl ?? null,
+        t.sourceExternalId ?? 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, source_connector_id, source_external_url, source_external_id)
+     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,
+    task.sourceConnectorId ?? null,
+    task.sourceExternalUrl ?? null,
+    task.sourceExternalId ?? 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 (updates.sourceConnectorId !== void 0) {
+    sets.push("source_connector_id = ?");
+    params.push(updates.sourceConnectorId);
+  }
+  if (updates.sourceExternalUrl !== void 0) {
+    sets.push("source_external_url = ?");
+    params.push(updates.sourceExternalUrl);
+  }
+  if (updates.sourceExternalId !== void 0) {
+    sets.push("source_external_id = ?");
+    params.push(updates.sourceExternalId);
+  }
+  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) {
+  const projectId = project.projectId ?? randomUUID();
+  getDb().prepare(
+    "INSERT INTO projects (name, path, preferred_agents, icon, icon_color, host_ids, workspace_id, project_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",
+    projectId
+  );
+}
+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 },
+    ...r.source_connector_id != null && { sourceConnectorId: r.source_connector_id },
+    ...r.source_external_url != null && { sourceExternalUrl: r.source_external_url },
+    ...r.source_external_id != null && {
+      sourceExternalId: r.source_external_id
+    }
+  };
+}
+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",
+    ...r.project_id != null && r.project_id !== "" && { projectId: r.project_id }
+  };
+}
+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 mapWorkflowNodeRow(n) {
+  return {
+    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 },
+    ...n.agent_type != null && { agentType: n.agent_type },
+    ...n.project_name != null && { projectName: n.project_name },
+    ...n.project_path != null && { projectPath: n.project_path },
+    ...n.approved_at != null && { approvedAt: n.approved_at }
+  };
+}
+function loadWorkflowRunNodes(d, runIds) {
+  if (runIds.length === 0) return /* @__PURE__ */ new Map();
+  const placeholders = runIds.map(() => "?").join(",");
+  const rows = d.prepare(`SELECT * FROM workflow_run_nodes WHERE run_id IN (${placeholders})`).all(...runIds);
+  const byRunId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const arr = byRunId.get(row.run_id);
+    if (arr) arr.push(mapWorkflowNodeRow(row));
+    else byRunId.set(row.run_id, [mapWorkflowNodeRow(row)]);
+  }
+  return byRunId;
+}
+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);
+  const nodesByRunId = loadWorkflowRunNodes(
+    d,
+    rows.map((r) => r.id)
+  );
+  return rows.map((r) => ({
+    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: nodesByRunId.get(r.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);
+  const nodesByRunId = loadWorkflowRunNodes(
+    d,
+    rows.map((r) => r.id)
+  );
+  return rows.map((r) => ({
+    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: nodesByRunId.get(r.id) ?? []
+  }));
+}
+
+// ../server/src/config-manager.ts
+var DB_DIR = getDataDir();
+var ConfigManager = class {
+  changeCallbacks = [];
+  dbWatcher = null;
+  debounceTimer = null;
+  cachedConfig = null;
+  init() {
+    initDatabase();
+  }
+  close() {
+    this.stopWatchingDb();
+    closeDatabase();
+  }
+  /** Полный сброс — удаляет БД и переинициализирует пустую схему.
+   *  Инвалидирует кэш и будит подписчиков, чтобы UI увидел пустой конфиг. */
+  factoryReset() {
+    this.stopWatchingDb();
+    this.cachedConfig = null;
+    factoryResetDatabase();
+    this.notifyChanged();
+  }
+  loadConfig() {
+    if (this.cachedConfig) return this.cachedConfig;
+    try {
+      const config = loadConfig();
+      const seeded = this.seedCodexDefaults(this.seedClaudeDefaults(config));
+      this.cachedConfig = seeded;
+      return seeded;
+    } 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: []
+      };
+    }
+  }
+  /** При первом запуске (или после factory-reset) в DB нет ни
+   *  `claudeDefaultModel`, ни `claudeDefaultEffort`, и пользователь видит в
+   *  пикерах настроек fallback-значения через `?? CLAUDE_DEFAULT_MODEL`. До
+   *  фикса это приводило к расхождению: UI показывал «Sonnet 4.6 / medium»,
+   *  а сервер при создании сессии не находил дефолтов и не слал ни `/model`,
+   *  ни `/effort`. Теперь записываем стандартные значения в DB сразу, чтобы
+   *  источник правды был один. */
+  seedClaudeDefaults(config) {
+    const needsModel = config.defaults.claudeDefaultModel == null;
+    const needsEffort = config.defaults.claudeDefaultEffort == null;
+    if (!needsModel && !needsEffort) return config;
+    const seeded = {
+      ...config,
+      defaults: {
+        ...config.defaults,
+        ...needsModel ? { claudeDefaultModel: CLAUDE_DEFAULT_MODEL_ID } : {},
+        ...needsEffort ? { claudeDefaultEffort: CLAUDE_DEFAULT_EFFORT } : {}
+      }
+    };
+    try {
+      saveConfig(seeded);
+      logger_default.info(
+        `[config-manager] seeded claude defaults: model=${needsModel ? CLAUDE_DEFAULT_MODEL_ID : "(kept)"} effort=${needsEffort ? CLAUDE_DEFAULT_EFFORT : "(kept)"}`
+      );
+    } catch (err) {
+      logger_default.warn(
+        `[config-manager] failed to persist seeded claude defaults: ${err.message}`
+      );
+    }
+    return seeded;
+  }
+  /** Аналог seedClaudeDefaults для codex: при первом запуске прописывает в DB
+   *  значения по умолчанию, чтобы UI и сервер видели одно и то же. Заодно
+   *  мигрирует устаревшие id (см. CODEX_OBSOLETE_MODEL_IDS) на актуальный
+   *  дефолт — иначе пикер в UI показывал бы пустую опцию, а сервер слал бы в
+   *  codex CLI несуществующий --model и сессия падала бы при старте. */
+  seedCodexDefaults(config) {
+    const stored = config.defaults.codexDefaultModel;
+    const needsModel = stored == null || typeof stored === "string" && CODEX_OBSOLETE_MODEL_IDS.includes(stored);
+    const needsEffort = config.defaults.codexDefaultEffort == null;
+    if (!needsModel && !needsEffort) return config;
+    const seeded = {
+      ...config,
+      defaults: {
+        ...config.defaults,
+        ...needsModel ? { codexDefaultModel: CODEX_DEFAULT_MODEL_ID } : {},
+        ...needsEffort ? { codexDefaultEffort: CODEX_DEFAULT_EFFORT } : {}
+      }
+    };
+    try {
+      saveConfig(seeded);
+      logger_default.info(
+        `[config-manager] seeded codex defaults: model=${needsModel ? CODEX_DEFAULT_MODEL_ID : "(kept)"} effort=${needsEffort ? CODEX_DEFAULT_EFFORT : "(kept)"}`
+      );
+    } catch (err) {
+      logger_default.warn(
+        `[config-manager] failed to persist seeded codex defaults: ${err.message}`
+      );
+    }
+    return seeded;
+  }
+  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).
+   * Слушаем ТОЛЬКО `.db-signal` — явный сигнальный файл, который трогают
+   * внешние писатели через `dbSignalChange()`. Внутренние мутации сервера
+   * и так зовут `notifyChanged()` напрямую (см. saveConfig/notifyChanged
+   * call-sites). Раньше watcher следил ещё за `.db` и `.db-wal`, и любая
+   * запись в БД (session-persistence, tasks, etc.) → менялся WAL-файл →
+   * срабатывал debounce 300мс → notifyChanged → реконфигурация всех
+   * менеджеров + broadcast клиентам. На активной сессии это давало
+   * непрекращающийся спам в логах и лишние IPC-броадкасты.
+   */
+  watchDb() {
+    if (this.dbWatcher) return;
+    try {
+      this.dbWatcher = fs4.watch(DB_DIR, (eventType, filename) => {
+        if (!filename || !filename.endsWith(".db-signal")) 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 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) {
+  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 = 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) {
+  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 fs5 from "fs";
+import path5 from "path";
+import os2 from "os";
+import { execFileSync as execFileSync2 } from "child_process";
+import { WebSocket } from "ws";
+var PORT_FILE = path5.join(os2.homedir(), BASEGRID_DIR_NAME, "ws-port");
+var TIMEOUT_MS = 1e4;
+var IS_WIN = process.platform === "win32";
+var PORT_FILE_MISSING_MSG = IS_WIN ? `BaseGrid port file not found (~/.basegrid/ws-port).
+The app may be running but the port file was deleted (e.g. by another instance shutting down).
+To fix, find the BaseGrid process and its listening port:
+  powershell -c "Get-NetTCPConnection -State Listen -OwningProcess (Get-Process BaseGrid).Id | Select LocalPort"
+Then write the WS port to the file:
+  echo {"port":<PORT>,"pid":<PID>} > %USERPROFILE%\\.basegrid\\ws-port
+Or restart BaseGrid to regenerate it.` : `BaseGrid port file not found (~/.basegrid/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 BaseGrid
+Then write the WS port (the one on *:<port>) to the file:
+  echo '{"port":<PORT>,"pid":<PID>}' > ~/.basegrid/ws-port
+Or restart BaseGrid to regenerate it.`;
+var PORT_FILE_INVALID_MSG = `BaseGrid port file exists but contains invalid data (~/.basegrid/ws-port).
+Delete it and restart BaseGrid, or overwrite it with the correct port:
+  ${IS_WIN ? "del %USERPROFILE%\\.basegrid\\ws-port" : "rm ~/.basegrid/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 = execFileSync2(
+        "tasklist",
+        ["/FI", "IMAGENAME eq BaseGrid.exe", "/FO", "CSV", "/NH"],
+        EXEC_OPTS
+      );
+      const pidMatch = taskOut.match(/"BaseGrid\.exe","(\d+)"/);
+      if (!pidMatch) return null;
+      const pid = pidMatch[1];
+      const lines = execFileSync2("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 = execFileSync2("lsof", ["-iTCP", "-sTCP:LISTEN", "-P", "-n"], EXEC_OPTS).split(
+        "\n"
+      );
+      let fallback = null;
+      for (const line of lines) {
+        if (!line.includes("BaseGrid")) 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 {
+      fs5.mkdirSync(path5.dirname(PORT_FILE), { recursive: true });
+      fs5.writeFileSync(PORT_FILE, JSON.stringify({ port: discovered }), "utf-8");
+    } catch {
+    }
+    return { port: discovered };
+  }
+  return { port: null, reason: "missing" };
+}
+function readPort() {
+  try {
+    const raw = fs5.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 BaseGrid 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 BaseGrid 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) or "recent" (past sessions).',
+    {
+      filter: z4.enum(["active", "recent"]).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 {
+          const sessions = await rpcCall("sessions:getRecent", args.project_path);
+          return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
+        }
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "launch_session",
+    "Launch an AI agent session (interactive terminal or headless). Requires the BaseGrid 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 BaseGrid 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 BaseGrid 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). 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"]).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.string(), 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 BaseGrid 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 BaseGrid 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: "basegrid", 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.6.5" : 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);
+});