@planflow-tools/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2261 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { APP_NAME, APP_VERSION } from "@planflow/shared";
+
+// src/errors.ts
+var PlanFlowError = class extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.name = "PlanFlowError";
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details
+    };
+  }
+};
+var AuthError = class extends PlanFlowError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", details);
+    this.name = "AuthError";
+  }
+};
+var ApiError = class extends PlanFlowError {
+  statusCode;
+  constructor(message, statusCode, details) {
+    super(message, "API_ERROR", details);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+  }
+};
+var ConfigError = class extends PlanFlowError {
+  constructor(message, details) {
+    super(message, "CONFIG_ERROR", details);
+    this.name = "ConfigError";
+  }
+};
+var ToolError = class extends PlanFlowError {
+  toolName;
+  constructor(message, toolName, details) {
+    super(message, "TOOL_ERROR", { ...details, toolName });
+    this.name = "ToolError";
+    this.toolName = toolName;
+  }
+};
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  minLevel = "info";
+  prefix = "[PlanFlow MCP]";
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.minLevel];
+  }
+  formatMessage(level, message, meta) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const levelStr = level.toUpperCase().padEnd(5);
+    let formatted = `${timestamp} ${levelStr} ${this.prefix} ${message}`;
+    if (meta && Object.keys(meta).length > 0) {
+      formatted += ` ${JSON.stringify(meta)}`;
+    }
+    return formatted;
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.error(this.formatMessage("debug", message, meta));
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.error(this.formatMessage("info", message, meta));
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.error(this.formatMessage("warn", message, meta));
+    }
+  }
+  error(message, meta) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message, meta));
+    }
+  }
+};
+var logger = new Logger();
+
+// src/tools/login.ts
+import { z as z2 } from "zod";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+var ConfigSchema = z.object({
+  apiToken: z.string().optional(),
+  apiUrl: z.string().url().default("https://api.planflow.tools"),
+  userId: z.string().uuid().optional(),
+  userEmail: z.string().email().optional()
+});
+var DEFAULT_CONFIG = {
+  apiUrl: "https://api.planflow.tools"
+};
+function getConfigDir() {
+  const home = homedir();
+  return join(home, ".config", "planflow");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+    logger.debug("Created config directory", { path: configDir });
+  }
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    logger.debug("No config file found, using defaults");
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const config = ConfigSchema.parse(parsed);
+    logger.debug("Loaded config from disk");
+    return config;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      logger.warn("Invalid config file, using defaults", { errors: error.errors });
+      return DEFAULT_CONFIG;
+    }
+    throw new ConfigError("Failed to load configuration", { error: String(error) });
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const configPath = getConfigPath();
+  const existingConfig = loadConfig();
+  const newConfig = ConfigSchema.parse({ ...existingConfig, ...config });
+  try {
+    writeFileSync(configPath, JSON.stringify(newConfig, null, 2), "utf-8");
+    logger.debug("Saved config to disk");
+    return newConfig;
+  } catch (error) {
+    throw new ConfigError("Failed to save configuration", { error: String(error) });
+  }
+}
+function clearCredentials() {
+  const config = loadConfig();
+  saveConfig({
+    ...config,
+    apiToken: void 0,
+    userId: void 0,
+    userEmail: void 0
+  });
+  logger.info("Cleared stored credentials");
+}
+function isAuthenticated() {
+  const config = loadConfig();
+  return !!config.apiToken;
+}
+function getApiToken() {
+  const config = loadConfig();
+  if (!config.apiToken) {
+    throw new ConfigError("Not authenticated. Please run planflow_login first.");
+  }
+  return config.apiToken;
+}
+function getApiUrl() {
+  const config = loadConfig();
+  return config.apiUrl;
+}
+
+// src/api-client.ts
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_RETRIES = 3;
+var RETRY_DELAY = 1e3;
+var ApiClient = class {
+  baseUrl;
+  token;
+  timeout;
+  constructor(options) {
+    this.baseUrl = getApiUrl();
+    this.token = null;
+    this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+  }
+  // ============================================================
+  // Token Management
+  // ============================================================
+  /**
+   * Set authentication token directly
+   */
+  setToken(token) {
+    this.token = token;
+    logger.debug("API token set");
+  }
+  /**
+   * Clear the current token
+   */
+  clearToken() {
+    this.token = null;
+    logger.debug("API token cleared");
+  }
+  /**
+   * Load token from config file
+   * @returns true if token was loaded successfully
+   */
+  loadToken() {
+    try {
+      this.token = getApiToken();
+      logger.debug("API token loaded from config");
+      return true;
+    } catch {
+      this.token = null;
+      return false;
+    }
+  }
+  /**
+   * Check if client has a token set
+   */
+  hasToken() {
+    return this.token !== null;
+  }
+  /**
+   * Check if authenticated (has valid token in config)
+   */
+  isAuthenticated() {
+    return isAuthenticated();
+  }
+  /**
+   * Get the current API base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  // ============================================================
+  // HTTP Request Methods
+  // ============================================================
+  /**
+   * Make an authenticated HTTP request with retry logic
+   */
+  async request(method, path, options) {
+    const { body, requireAuth = true, retries = MAX_RETRIES } = options ?? {};
+    if (requireAuth && !this.token) {
+      throw new AuthError("Not authenticated. Please run planflow_login first.");
+    }
+    const url = `${this.baseUrl}${path}`;
+    logger.debug("API request", { method, url });
+    let lastError = null;
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (this.token) {
+          headers["Authorization"] = `Bearer ${this.token}`;
+        }
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const data = await response.json();
+        if (response.status === 401) {
+          throw new AuthError(
+            data.error ?? "Authentication failed. Your token may be invalid or expired.",
+            { statusCode: 401 }
+          );
+        }
+        if (response.status === 403) {
+          throw new AuthError(
+            data.error ?? "Access denied. You do not have permission to perform this action.",
+            { statusCode: 403 }
+          );
+        }
+        if (response.status === 404) {
+          throw new ApiError(data.error ?? "Resource not found", 404);
+        }
+        if (response.status === 400) {
+          throw new ApiError(data.error ?? "Invalid request", 400, {
+            details: data.details
+          });
+        }
+        if (response.status >= 500) {
+          throw new ApiError(
+            data.error ?? `Server error (${response.status})`,
+            response.status
+          );
+        }
+        if (!response.ok) {
+          throw new ApiError(
+            data.error ?? `Request failed with status ${response.status}`,
+            response.status
+          );
+        }
+        if (!data.success) {
+          throw new ApiError(data.error ?? "Request failed");
+        }
+        if (data.data === void 0) {
+          throw new ApiError("Empty response data");
+        }
+        logger.debug("API response success", { method, url, status: response.status });
+        return data.data;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof AuthError) {
+          throw error;
+        }
+        if (error instanceof ApiError) {
+          const status = error.statusCode;
+          if (status && status >= 400 && status < 500 && status !== 408 && status !== 429) {
+            throw error;
+          }
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          lastError = new ApiError(`Request timeout after ${this.timeout}ms`, 408);
+        }
+        if (attempt < retries) {
+          const delay = RETRY_DELAY * Math.pow(2, attempt - 1);
+          logger.debug("Retrying request", { attempt, delay, error: String(error) });
+          await this.sleep(delay);
+          continue;
+        }
+      }
+    }
+    if (lastError instanceof ApiError || lastError instanceof AuthError) {
+      throw lastError;
+    }
+    throw new ApiError(
+      `Network error: ${lastError?.message ?? "Unknown error"}`,
+      void 0,
+      { originalError: String(lastError) }
+    );
+  }
+  /**
+   * Sleep for a given number of milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ============================================================
+  // Auth Endpoints
+  // ============================================================
+  /**
+   * Get current authenticated user info
+   */
+  async getCurrentUser() {
+    return this.request("GET", "/auth/me");
+  }
+  /**
+   * Verify an API token (can be used without authentication)
+   */
+  async verifyToken(token) {
+    return this.request("POST", "/api-tokens/verify", {
+      body: { token },
+      requireAuth: false
+    });
+  }
+  // ============================================================
+  // Project Endpoints
+  // ============================================================
+  /**
+   * List all projects for the authenticated user
+   */
+  async listProjects() {
+    const response = await this.request("GET", "/projects");
+    return response.projects;
+  }
+  /**
+   * Get a single project by ID
+   */
+  async getProject(id) {
+    const response = await this.request("GET", `/projects/${id}`);
+    return response.project;
+  }
+  /**
+   * Create a new project
+   */
+  async createProject(data) {
+    const response = await this.request("POST", "/projects", {
+      body: data
+    });
+    return response.project;
+  }
+  /**
+   * Update an existing project
+   */
+  async updateProject(id, data) {
+    const response = await this.request("PUT", `/projects/${id}`, {
+      body: data
+    });
+    return response.project;
+  }
+  /**
+   * Delete a project
+   */
+  async deleteProject(id) {
+    await this.request("DELETE", `/projects/${id}`);
+  }
+  /**
+   * Get project plan content
+   */
+  async getProjectPlan(id) {
+    return this.request("GET", `/projects/${id}/plan`);
+  }
+  /**
+   * Update project plan content
+   */
+  async updateProjectPlan(id, plan) {
+    return this.request("PUT", `/projects/${id}/plan`, {
+      body: { plan }
+    });
+  }
+  // ============================================================
+  // Task Endpoints
+  // ============================================================
+  /**
+   * List all tasks for a project
+   */
+  async listTasks(projectId) {
+    return this.request("GET", `/projects/${projectId}/tasks`);
+  }
+  /**
+   * Update a single task by its task ID (e.g., "T1.1")
+   * This is a convenience wrapper around bulkUpdateTasks
+   */
+  async updateTask(projectId, taskUuid, updates) {
+    const response = await this.bulkUpdateTasks(projectId, [
+      { id: taskUuid, ...updates }
+    ]);
+    return response.tasks[0] ?? null;
+  }
+  /**
+   * Update task status by task ID (e.g., "T1.1")
+   * First fetches tasks to find the UUID, then updates
+   */
+  async updateTaskStatus(projectId, taskId, status) {
+    const { tasks } = await this.listTasks(projectId);
+    const task = tasks.find((t) => t.taskId === taskId);
+    if (!task) {
+      throw new ApiError(`Task ${taskId} not found in project`, 404);
+    }
+    return this.updateTask(projectId, task.id, { status });
+  }
+  /**
+   * Bulk update multiple tasks
+   */
+  async bulkUpdateTasks(projectId, tasks) {
+    return this.request("PUT", `/projects/${projectId}/tasks`, {
+      body: { tasks }
+    });
+  }
+  // ============================================================
+  // Notification Endpoints
+  // ============================================================
+  /**
+   * List notifications for the authenticated user
+   */
+  async listNotifications(options) {
+    const params = new URLSearchParams();
+    if (options?.projectId) params.append("projectId", options.projectId);
+    if (options?.unreadOnly) params.append("unreadOnly", "true");
+    if (options?.limit) params.append("limit", String(options.limit));
+    const query = params.toString();
+    const path = `/notifications${query ? "?" + query : ""}`;
+    return this.request("GET", path);
+  }
+  /**
+   * Mark a notification as read
+   */
+  async markNotificationRead(notificationId) {
+    return this.request("PUT", `/notifications/${notificationId}/read`);
+  }
+  /**
+   * Mark all notifications as read
+   */
+  async markAllNotificationsRead(projectId) {
+    const body = projectId ? { projectId } : void 0;
+    return this.request("PUT", "/notifications/read-all", { body });
+  }
+  // ============================================================
+  // Utility Methods
+  // ============================================================
+  /**
+   * Health check - verify API is reachable
+   */
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get API information
+   */
+  async getApiInfo() {
+    const response = await fetch(`${this.baseUrl}/`, {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      throw new ApiError("Failed to get API info", response.status);
+    }
+    return response.json();
+  }
+};
+var apiClient = null;
+function getApiClient() {
+  if (!apiClient) {
+    apiClient = new ApiClient();
+    apiClient.loadToken();
+  }
+  return apiClient;
+}
+function resetApiClient() {
+  apiClient = null;
+}
+function createApiClient(options) {
+  return new ApiClient(options);
+}
+
+// src/tools/types.ts
+function createSuccessResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function createErrorResult(text) {
+  return {
+    content: [{ type: "text", text }],
+    isError: true
+  };
+}
+function formatTable(headers, rows, options) {
+  const padding = options?.padding ?? 2;
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+  );
+  const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join(" ".repeat(padding));
+  const separator = widths.map((w) => "-".repeat(w)).join(" ".repeat(padding));
+  const dataRows = rows.map(
+    (row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join(" ".repeat(padding))
+  );
+  return [headerRow, separator, ...dataRows].join("\n");
+}
+function formatKeyValue(pairs) {
+  const maxKeyLength = Math.max(...Object.keys(pairs).map((k) => k.length));
+  return Object.entries(pairs).map(([key, value]) => `${key.padEnd(maxKeyLength)}: ${String(value)}`).join("\n");
+}
+
+// src/tools/login.ts
+var LoginInputSchema = z2.object({
+  token: z2.string().min(1, "API token is required")
+});
+var loginTool = {
+  name: "planflow_login",
+  description: `Authenticate with PlanFlow using an API token.
+
+Get your API token from the PlanFlow dashboard at https://planflow.tools/settings/api-tokens
+
+Usage:
+  planflow_login(token: "your-api-token")
+
+After successful login, you can use other PlanFlow tools to manage your projects and tasks.`,
+  inputSchema: LoginInputSchema,
+  async execute(input) {
+    const { token } = input;
+    logger.info("Attempting to authenticate with PlanFlow");
+    if (isAuthenticated()) {
+      const config = loadConfig();
+      logger.debug("User already authenticated", { email: config.userEmail });
+      return createSuccessResult(
+        `\u26A0\uFE0F Already logged in as ${config.userEmail}
+
+To switch accounts, run planflow_logout first, then login with the new token.`
+      );
+    }
+    try {
+      const client = createApiClient();
+      logger.debug("Verifying API token");
+      const verifyResponse = await client.verifyToken(token);
+      saveConfig({
+        apiToken: token,
+        userId: verifyResponse.user.id,
+        userEmail: verifyResponse.user.email
+      });
+      resetApiClient();
+      logger.info("Successfully authenticated", { email: verifyResponse.user.email });
+      const output = [
+        "\u2705 Successfully logged in to PlanFlow!\n",
+        formatKeyValue({
+          "User": verifyResponse.user.name,
+          "Email": verifyResponse.user.email,
+          "Token": verifyResponse.tokenName
+        }),
+        "\n\n\u{1F389} You can now use PlanFlow tools:",
+        "  \u2022 planflow_projects  - List your projects",
+        "  \u2022 planflow_create    - Create a new project",
+        "  \u2022 planflow_sync      - Sync project plans",
+        "  \u2022 planflow_task_list - View project tasks",
+        "  \u2022 planflow_whoami    - Show current user info"
+      ].join("\n");
+      return createSuccessResult(output);
+    } catch (error) {
+      logger.error("Authentication failed", { error: String(error) });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          "\u274C Authentication failed: Invalid or expired API token.\n\nPlease check your token and try again.\nGet a new token at: https://planflow.tools/settings/api-tokens"
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Authentication failed: ${message}
+
+Please check your internet connection and try again.`
+      );
+    }
+  }
+};
+
+// src/tools/logout.ts
+import { z as z3 } from "zod";
+var LogoutInputSchema = z3.object({});
+var logoutTool = {
+  name: "planflow_logout",
+  description: `Log out from PlanFlow and clear stored credentials.
+
+This will remove your API token from local storage. You will need to login again with planflow_login to use other PlanFlow tools.
+
+Usage:
+  planflow_logout()
+
+No parameters required.`,
+  inputSchema: LogoutInputSchema,
+  async execute(_input) {
+    logger.info("Attempting to logout from PlanFlow");
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        "\u26A0\uFE0F Not currently logged in.\n\nUse planflow_login to authenticate first."
+      );
+    }
+    try {
+      const config = loadConfig();
+      const userEmail = config.userEmail ?? "unknown";
+      clearCredentials();
+      resetApiClient();
+      logger.info("Successfully logged out", { email: userEmail });
+      return createSuccessResult(
+        `\u2705 Successfully logged out from PlanFlow!
+
+Goodbye, ${userEmail}!
+
+\u{1F510} Your API token has been removed from local storage.
+
+To login again, use:
+  planflow_login(token: "your-api-token")
+
+Get your token at: https://planflow.tools/settings/api-tokens`
+      );
+    } catch (error) {
+      logger.error("Logout failed", { error: String(error) });
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Logout failed: ${message}
+
+Please try again or manually delete the config file at:
+  ~/.config/planflow/config.json`
+      );
+    }
+  }
+};
+
+// src/tools/whoami.ts
+import { z as z4 } from "zod";
+var WhoamiInputSchema = z4.object({});
+function formatDate(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+var whoamiTool = {
+  name: "planflow_whoami",
+  description: `Show information about the currently authenticated PlanFlow user.
+
+Displays your user profile including name, email, account creation date, and authentication method.
+
+Usage:
+  planflow_whoami()
+
+No parameters required. You must be logged in first with planflow_login.`,
+  inputSchema: WhoamiInputSchema,
+  async execute(_input) {
+    logger.info("Fetching current user information");
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    try {
+      const client = getApiClient();
+      const response = await client.getCurrentUser();
+      const { user, authType } = response;
+      const config = loadConfig();
+      logger.info("Successfully retrieved user info", { email: user.email });
+      const output = [
+        "\u{1F464} Current User\n",
+        formatKeyValue({
+          "Name": user.name,
+          "Email": user.email,
+          "User ID": user.id,
+          "Auth Type": authType === "api-token" ? "API Token" : "JWT",
+          "Created": formatDate(user.createdAt),
+          "Updated": formatDate(user.updatedAt)
+        }),
+        "\n\n\u{1F4CA} Session Info",
+        formatKeyValue({
+          "API URL": config.apiUrl,
+          "Status": "\u2705 Connected"
+        }),
+        "\n\n\u{1F4A1} Available commands:",
+        "  \u2022 planflow_projects  - List your projects",
+        "  \u2022 planflow_create    - Create a new project",
+        "  \u2022 planflow_sync      - Sync project plans",
+        "  \u2022 planflow_logout    - Log out"
+      ].join("\n");
+      return createSuccessResult(output);
+    } catch (error) {
+      logger.error("Failed to fetch user info", { error: String(error) });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to fetch user info: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+
+// src/tools/projects.ts
+import { z as z5 } from "zod";
+var ProjectsInputSchema = z5.object({});
+function formatDate2(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function truncate(str, maxLength) {
+  if (!str) return "-";
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+var projectsTool = {
+  name: "planflow_projects",
+  description: `List all your PlanFlow projects.
+
+Displays a table of all projects with their names, descriptions, and creation dates.
+
+Usage:
+  planflow_projects()
+
+No parameters required. You must be logged in first with planflow_login.
+
+Returns:
+  - Project ID (use for other commands)
+  - Project name
+  - Description (truncated)
+  - Created date
+  - Updated date`,
+  inputSchema: ProjectsInputSchema,
+  async execute(_input) {
+    logger.info("Fetching projects list");
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    try {
+      const client = getApiClient();
+      const projects = await client.listProjects();
+      logger.info("Successfully retrieved projects", { count: projects.length });
+      if (projects.length === 0) {
+        return createSuccessResult(
+          `\u{1F4C1} No projects found.
+
+You don't have any projects yet.
+
+\u{1F4A1} Create your first project:
+  planflow_create(name: "My Project", description: "Optional description")
+
+Or create one at: https://planflow.tools/projects/new`
+        );
+      }
+      const headers = ["ID", "Name", "Description", "Created", "Updated"];
+      const rows = projects.map((project) => [
+        project.id.slice(0, 8) + "...",
+        // Show first 8 chars of UUID
+        truncate(project.name, 25),
+        truncate(project.description, 30),
+        formatDate2(project.createdAt),
+        formatDate2(project.updatedAt)
+      ]);
+      const output = [
+        `\u{1F4C1} Your Projects (${projects.length})
+`,
+        formatTable(headers, rows),
+        "\n\n\u{1F4A1} Commands:",
+        '  \u2022 planflow_sync(projectId: "...")     - Sync project plan',
+        '  \u2022 planflow_task_list(projectId: "...") - List project tasks',
+        '  \u2022 planflow_create(name: "...")        - Create new project',
+        "\n\u{1F4CB} Full project IDs:",
+        ...projects.map((p) => `  \u2022 ${p.name}: ${p.id}`)
+      ].join("\n");
+      return createSuccessResult(output);
+    } catch (error) {
+      logger.error("Failed to fetch projects", { error: String(error) });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to fetch projects: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+
+// src/tools/create.ts
+import { z as z6 } from "zod";
+var CreateInputSchema = z6.object({
+  name: z6.string().min(1, "Project name is required").max(255, "Project name must be at most 255 characters"),
+  description: z6.string().max(1e3, "Description must be at most 1000 characters").optional()
+});
+function formatDate3(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+var createTool = {
+  name: "planflow_create",
+  description: `Create a new PlanFlow project.
+
+Creates a new project with the specified name and optional description.
+
+Usage:
+  planflow_create(name: "My Project")
+  planflow_create(name: "My Project", description: "A description of my project")
+
+Parameters:
+  - name (required): Project name (1-255 characters)
+  - description (optional): Project description (max 1000 characters)
+
+You must be logged in first with planflow_login.
+
+Returns:
+  - Project ID (use for sync and task commands)
+  - Project name
+  - Description
+  - Created timestamp`,
+  inputSchema: CreateInputSchema,
+  async execute(input) {
+    logger.info("Creating new project", { name: input.name });
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    try {
+      const client = getApiClient();
+      const project = await client.createProject({
+        name: input.name,
+        description: input.description
+      });
+      logger.info("Successfully created project", { projectId: project.id });
+      const output = [
+        "\u2705 Project created successfully!\n",
+        formatKeyValue({
+          "Project ID": project.id,
+          "Name": project.name,
+          "Description": project.description || "(none)",
+          "Created": formatDate3(project.createdAt)
+        }),
+        "\n\n\u{1F4A1} Next steps:",
+        '  \u2022 planflow_sync(projectId: "' + project.id + '", direction: "push")  - Upload your PROJECT_PLAN.md',
+        '  \u2022 planflow_task_list(projectId: "' + project.id + '")               - View project tasks',
+        "  \u2022 planflow_projects()                                               - List all projects",
+        "\n\u{1F4CB} Save this project ID for future commands:",
+        `  ${project.id}`
+      ].join("\n");
+      return createSuccessResult(output);
+    } catch (error) {
+      logger.error("Failed to create project", { error: String(error) });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        if (error.statusCode === 400) {
+          return createErrorResult(
+            `\u274C Invalid project data: ${error.message}
+
+Please check:
+  \u2022 Name is between 1-255 characters
+  \u2022 Description is at most 1000 characters`
+          );
+        }
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to create project: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+
+// src/tools/sync.ts
+import { z as z7 } from "zod";
+var SyncInputSchema = z7.object({
+  projectId: z7.string().uuid("Invalid project ID format"),
+  direction: z7.enum(["push", "pull"]),
+  content: z7.string().optional()
+  // Required for push, ignored for pull
+});
+function formatDate4(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function countLines(content) {
+  if (!content) return 0;
+  return content.split("\n").length;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var syncTool = {
+  name: "planflow_sync",
+  description: `Sync PROJECT_PLAN.md with PlanFlow cloud.
+
+Bidirectional synchronization between local plan files and the cloud.
+
+Usage:
+  planflow_sync(projectId: "uuid", direction: "push", content: "# Plan...")  - Upload local plan
+  planflow_sync(projectId: "uuid", direction: "pull")                        - Download cloud plan
+
+Parameters:
+  - projectId (required): Project UUID from planflow_create or planflow_projects
+  - direction (required): "push" to upload, "pull" to download
+  - content (required for push): The markdown content to upload
+
+You must be logged in first with planflow_login.
+
+Returns:
+  - Push: Confirmation with size and timestamp
+  - Pull: Full plan content (markdown) to save locally`,
+  inputSchema: SyncInputSchema,
+  async execute(input) {
+    logger.info("Syncing project plan", {
+      projectId: input.projectId,
+      direction: input.direction
+    });
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    if (input.direction === "push" && !input.content) {
+      logger.debug("Push requested without content");
+      return createErrorResult(
+        `\u274C Content is required for push operation.
+
+Please provide the plan content:
+  planflow_sync(
+    projectId: "${input.projectId}",
+    direction: "push",
+    content: "# Your plan content here..."
+  )
+
+\u{1F4A1} Tip: Read your PROJECT_PLAN.md file and pass its content.`
+      );
+    }
+    try {
+      const client = getApiClient();
+      if (input.direction === "push") {
+        return await executePush(client, input.projectId, input.content);
+      } else {
+        return await executePull(client, input.projectId);
+      }
+    } catch (error) {
+      logger.error("Failed to sync project plan", { error: String(error) });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        if (error.statusCode === 404) {
+          return createErrorResult(
+            "\u274C Project not found.\n\nPlease check the project ID and try again.\nRun planflow_projects() to list your available projects."
+          );
+        }
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to sync plan: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+async function executePush(client, projectId, content) {
+  logger.info("Pushing plan to cloud", { projectId, contentLength: content.length });
+  const response = await client.updateProjectPlan(projectId, content);
+  const bytes = new TextEncoder().encode(content).length;
+  const lines = countLines(content);
+  const output = [
+    "\u2705 Plan synced to cloud!\n",
+    formatKeyValue({
+      "Project": response.projectName,
+      "Direction": "push",
+      "Size": `${formatBytes(bytes)} (${lines} lines)`,
+      "Updated": formatDate4(response.updatedAt)
+    }),
+    "\n\n\u{1F4A1} Tip: Your local changes are now saved to the cloud."
+  ].join("\n");
+  logger.info("Successfully pushed plan", { projectId });
+  return createSuccessResult(output);
+}
+async function executePull(client, projectId) {
+  logger.info("Pulling plan from cloud", { projectId });
+  const response = await client.getProjectPlan(projectId);
+  if (!response.plan) {
+    const output2 = [
+      "\u26A0\uFE0F No plan exists for this project yet.\n",
+      formatKeyValue({
+        "Project": response.projectName,
+        "Project ID": response.projectId
+      }),
+      "\n\n\u{1F4A1} Tip: Create a PROJECT_PLAN.md locally and use 'push' to upload it."
+    ].join("\n");
+    return createSuccessResult(output2);
+  }
+  const bytes = new TextEncoder().encode(response.plan).length;
+  const lines = countLines(response.plan);
+  const output = [
+    "\u2705 Plan retrieved from cloud!\n",
+    formatKeyValue({
+      "Project": response.projectName,
+      "Direction": "pull",
+      "Size": `${formatBytes(bytes)} (${lines} lines)`,
+      "Updated": formatDate4(response.updatedAt)
+    }),
+    "\n\n---",
+    response.plan,
+    "---",
+    "\n\u{1F4A1} Tip: Save this content to PROJECT_PLAN.md in your project."
+  ].join("\n");
+  logger.info("Successfully pulled plan", { projectId, contentLength: response.plan.length });
+  return createSuccessResult(output);
+}
+
+// src/tools/task-list.ts
+import { z as z8 } from "zod";
+var TaskListInputSchema = z8.object({
+  projectId: z8.string().uuid("Project ID must be a valid UUID"),
+  status: z8.enum(["TODO", "IN_PROGRESS", "DONE", "BLOCKED"]).optional().describe("Filter tasks by status")
+});
+function truncate2(str, maxLength) {
+  if (!str) return "-";
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function getStatusEmoji(status) {
+  switch (status) {
+    case "TODO":
+      return "\u{1F4CB}";
+    case "IN_PROGRESS":
+      return "\u{1F504}";
+    case "DONE":
+      return "\u2705";
+    case "BLOCKED":
+      return "\u{1F6AB}";
+    default:
+      return "\u2753";
+  }
+}
+function getComplexityIndicator(complexity) {
+  switch (complexity) {
+    case "Low":
+      return "\u{1F7E2}";
+    case "Medium":
+      return "\u{1F7E1}";
+    case "High":
+      return "\u{1F534}";
+    default:
+      return "\u26AA";
+  }
+}
+var taskListTool = {
+  name: "planflow_task_list",
+  description: `List all tasks for a PlanFlow project.
+
+Displays a table of tasks with their status, complexity, and dependencies.
+
+Usage:
+  planflow_task_list(projectId: "uuid")
+  planflow_task_list(projectId: "uuid", status: "TODO")
+
+Parameters:
+  - projectId (required): The project UUID (get from planflow_projects)
+  - status (optional): Filter by status - TODO, IN_PROGRESS, DONE, or BLOCKED
+
+Returns:
+  - Task ID (e.g., T1.1)
+  - Task name
+  - Status with emoji
+  - Complexity indicator
+  - Estimated hours
+  - Dependencies
+
+You must be logged in first with planflow_login.`,
+  inputSchema: TaskListInputSchema,
+  async execute(input) {
+    logger.info("Fetching tasks list", { projectId: input.projectId, status: input.status });
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    try {
+      const client = getApiClient();
+      const response = await client.listTasks(input.projectId);
+      logger.info("Successfully retrieved tasks", {
+        projectId: input.projectId,
+        count: response.tasks.length
+      });
+      let tasks = response.tasks;
+      if (input.status) {
+        tasks = tasks.filter((t) => t.status === input.status);
+        logger.debug("Filtered tasks by status", {
+          status: input.status,
+          filteredCount: tasks.length
+        });
+      }
+      if (tasks.length === 0) {
+        const filterMessage = input.status ? ` with status "${input.status}"` : "";
+        return createSuccessResult(
+          `\u{1F4CB} No tasks found${filterMessage}.
+
+Project: ${response.projectName}
+
+` + (input.status ? `\u{1F4A1} Try removing the status filter to see all tasks:
+  planflow_task_list(projectId: "${input.projectId}")` : `\u{1F4A1} Tasks are created when you sync your PROJECT_PLAN.md:
+  planflow_sync(projectId: "${input.projectId}", direction: "push")`)
+        );
+      }
+      tasks.sort((a, b) => {
+        const parseTaskId = (id) => {
+          const match = id.match(/T(\d+)\.(\d+)/);
+          if (!match) return [0, 0];
+          return [parseInt(match[1], 10), parseInt(match[2], 10)];
+        };
+        const [aMajor, aMinor] = parseTaskId(a.taskId);
+        const [bMajor, bMinor] = parseTaskId(b.taskId);
+        if (aMajor !== bMajor) return aMajor - bMajor;
+        return aMinor - bMinor;
+      });
+      const stats = {
+        total: response.tasks.length,
+        todo: response.tasks.filter((t) => t.status === "TODO").length,
+        inProgress: response.tasks.filter((t) => t.status === "IN_PROGRESS").length,
+        done: response.tasks.filter((t) => t.status === "DONE").length,
+        blocked: response.tasks.filter((t) => t.status === "BLOCKED").length
+      };
+      const progressPercent = Math.round(stats.done / stats.total * 100);
+      const headers = ["ID", "Name", "Status", "Complexity", "Est.", "Dependencies"];
+      const rows = tasks.map((task) => [
+        task.taskId,
+        truncate2(task.name, 30),
+        `${getStatusEmoji(task.status)} ${task.status}`,
+        `${getComplexityIndicator(task.complexity)} ${task.complexity}`,
+        task.estimatedHours ? `${task.estimatedHours}h` : "-",
+        task.dependencies.length > 0 ? task.dependencies.join(", ") : "-"
+      ]);
+      const progressBarLength = 10;
+      const filledBlocks = Math.floor(progressPercent / 10);
+      const progressBar = "\u{1F7E9}".repeat(filledBlocks) + "\u2B1C".repeat(progressBarLength - filledBlocks);
+      const filterLabel = input.status ? ` (filtered: ${input.status})` : "";
+      const output = [
+        `\u{1F4CB} Tasks for "${response.projectName}"${filterLabel}
+`,
+        `Progress: ${progressBar} ${progressPercent}%`,
+        `Total: ${stats.total} | \u2705 ${stats.done} | \u{1F504} ${stats.inProgress} | \u{1F4CB} ${stats.todo} | \u{1F6AB} ${stats.blocked}
+`,
+        formatTable(headers, rows),
+        "\n\n\u{1F4A1} Commands:",
+        `  \u2022 planflow_task_update(projectId: "${input.projectId}", taskId: "T1.1", status: "DONE")`,
+        `  \u2022 planflow_task_list(projectId: "${input.projectId}", status: "TODO")`,
+        `  \u2022 planflow_sync(projectId: "${input.projectId}", direction: "pull")`
+      ].join("\n");
+      return createSuccessResult(output);
+    } catch (error) {
+      logger.error("Failed to fetch tasks", { error: String(error), projectId: input.projectId });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        if (error.statusCode === 404) {
+          return createErrorResult(
+            `\u274C Project not found: ${input.projectId}
+
+Please check the project ID and try again.
+Use planflow_projects() to list your available projects.`
+          );
+        }
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to fetch tasks: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+
+// src/tools/task-update.ts
+import { z as z9 } from "zod";
+var TaskUpdateInputSchema = z9.object({
+  projectId: z9.string().uuid("Project ID must be a valid UUID"),
+  taskId: z9.string().describe('Task ID (e.g., "T1.1", "T2.3")'),
+  status: z9.enum(["TODO", "IN_PROGRESS", "DONE", "BLOCKED"]).describe("New status for the task")
+});
+function getStatusEmoji2(status) {
+  switch (status) {
+    case "TODO":
+      return "\u{1F4CB}";
+    case "IN_PROGRESS":
+      return "\u{1F504}";
+    case "DONE":
+      return "\u2705";
+    case "BLOCKED":
+      return "\u{1F6AB}";
+    default:
+      return "\u2753";
+  }
+}
+function getComplexityIndicator2(complexity) {
+  switch (complexity) {
+    case "Low":
+      return "\u{1F7E2}";
+    case "Medium":
+      return "\u{1F7E1}";
+    case "High":
+      return "\u{1F534}";
+    default:
+      return "\u26AA";
+  }
+}
+var taskUpdateTool = {
+  name: "planflow_task_update",
+  description: `Update task status in a PlanFlow project.
+
+Changes the status of a specific task (e.g., mark as done, in progress, or blocked).
+
+Usage:
+  planflow_task_update(projectId: "uuid", taskId: "T1.1", status: "IN_PROGRESS")
+  planflow_task_update(projectId: "uuid", taskId: "T2.3", status: "DONE")
+
+Parameters:
+  - projectId (required): The project UUID (get from planflow_projects)
+  - taskId (required): The task ID (e.g., "T1.1", "T2.3")
+  - status (required): New status - TODO, IN_PROGRESS, DONE, or BLOCKED
+
+Status meanings:
+  - TODO: Task not yet started
+  - IN_PROGRESS: Currently working on this task
+  - DONE: Task completed
+  - BLOCKED: Task cannot proceed (document blocker reason)
+
+You must be logged in first with planflow_login.`,
+  inputSchema: TaskUpdateInputSchema,
+  async execute(input) {
+    logger.info("Updating task", {
+      projectId: input.projectId,
+      taskId: input.taskId,
+      status: input.status
+    });
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    try {
+      const client = getApiClient();
+      const updatedTask = await client.updateTaskStatus(
+        input.projectId,
+        input.taskId,
+        input.status
+      );
+      if (!updatedTask) {
+        return createErrorResult(
+          `\u274C Failed to update task ${input.taskId}.
+
+The task may not exist or the update was rejected.
+Use planflow_task_list() to see available tasks.`
+        );
+      }
+      logger.info("Successfully updated task", {
+        taskId: input.taskId,
+        newStatus: input.status
+      });
+      const statusEmoji = getStatusEmoji2(updatedTask.status);
+      const complexityIndicator = getComplexityIndicator2(updatedTask.complexity);
+      const taskDetails = formatKeyValue({
+        "Task ID": updatedTask.taskId,
+        "Name": updatedTask.name,
+        "Status": `${statusEmoji} ${updatedTask.status}`,
+        "Complexity": `${complexityIndicator} ${updatedTask.complexity}`,
+        "Estimated": updatedTask.estimatedHours ? `${updatedTask.estimatedHours}h` : "-",
+        "Dependencies": updatedTask.dependencies.length > 0 ? updatedTask.dependencies.join(", ") : "None"
+      });
+      let nextSteps;
+      switch (input.status) {
+        case "IN_PROGRESS":
+          nextSteps = [
+            "\n\u{1F4A1} Next steps:",
+            `  \u2022 When finished: planflow_task_update(projectId: "${input.projectId}", taskId: "${input.taskId}", status: "DONE")`,
+            `  \u2022 If blocked: planflow_task_update(projectId: "${input.projectId}", taskId: "${input.taskId}", status: "BLOCKED")`,
+            `  \u2022 Sync changes: planflow_sync(projectId: "${input.projectId}", direction: "pull")`
+          ].join("\n");
+          break;
+        case "DONE":
+          nextSteps = [
+            "\n\u{1F389} Great work!",
+            "\n\u{1F4A1} Next steps:",
+            `  \u2022 Find next task: planflow_task_list(projectId: "${input.projectId}", status: "TODO")`,
+            `  \u2022 Sync changes: planflow_sync(projectId: "${input.projectId}", direction: "pull")`
+          ].join("\n");
+          break;
+        case "BLOCKED":
+          nextSteps = [
+            "\n\u26A0\uFE0F Task blocked - document the blocker:",
+            "  \u2022 What is blocking this task?",
+            "  \u2022 What needs to happen to unblock it?",
+            "  \u2022 Who can help resolve this?",
+            "\n\u{1F4A1} When unblocked:",
+            `  \u2022 planflow_task_update(projectId: "${input.projectId}", taskId: "${input.taskId}", status: "IN_PROGRESS")`
+          ].join("\n");
+          break;
+        default:
+          nextSteps = [
+            "\n\u{1F4A1} Commands:",
+            `  \u2022 Start task: planflow_task_update(projectId: "${input.projectId}", taskId: "${input.taskId}", status: "IN_PROGRESS")`,
+            `  \u2022 View all tasks: planflow_task_list(projectId: "${input.projectId}")`
+          ].join("\n");
+      }
+      const output = [
+        `${statusEmoji} Task ${input.taskId} updated to ${input.status}!
+`,
+        taskDetails,
+        nextSteps
+      ].join("\n");
+      return createSuccessResult(output);
+    } catch (error) {
+      logger.error("Failed to update task", {
+        error: String(error),
+        projectId: input.projectId,
+        taskId: input.taskId
+      });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        if (error.statusCode === 404) {
+          return createErrorResult(
+            `\u274C Task not found: ${input.taskId}
+
+Please check the task ID and try again.
+Use planflow_task_list(projectId: "${input.projectId}") to see available tasks.`
+          );
+        }
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to update task: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+
+// src/tools/task-next.ts
+import { z as z10 } from "zod";
+var TaskNextInputSchema = z10.object({
+  projectId: z10.string().uuid("Project ID must be a valid UUID")
+});
+function getComplexityIndicator3(complexity) {
+  switch (complexity) {
+    case "Low":
+      return "\u{1F7E2}";
+    case "Medium":
+      return "\u{1F7E1}";
+    case "High":
+      return "\u{1F534}";
+    default:
+      return "\u26AA";
+  }
+}
+function parsePhase(taskId) {
+  const match = taskId.match(/T(\d+)\./);
+  return match ? parseInt(match[1], 10) : 0;
+}
+function parseTaskOrder(taskId) {
+  const match = taskId.match(/T\d+\.(\d+)/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+function areDependenciesSatisfied(taskDependencies, completedTaskIds) {
+  return taskDependencies.every((dep) => completedTaskIds.has(dep));
+}
+function countDependentTasks(taskId, allTasks) {
+  return allTasks.filter((t) => t.dependencies.includes(taskId)).length;
+}
+function findCurrentPhase(tasks) {
+  const phaseMap = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const phase = parsePhase(task.taskId);
+    if (!phaseMap.has(phase)) {
+      phaseMap.set(phase, { total: 0, done: 0 });
+    }
+    const stats = phaseMap.get(phase);
+    stats.total++;
+    if (task.status === "DONE") {
+      stats.done++;
+    }
+  }
+  const phases = Array.from(phaseMap.keys()).sort((a, b) => a - b);
+  for (const phase of phases) {
+    const stats = phaseMap.get(phase);
+    if (stats.done < stats.total) {
+      return phase;
+    }
+  }
+  return phases[phases.length - 1] ?? 1;
+}
+function getRecentComplexity(tasks) {
+  const doneTasks = tasks.filter((t) => t.status === "DONE").sort((a, b) => {
+    const [aPhase, aOrder] = [parsePhase(a.taskId), parseTaskOrder(a.taskId)];
+    const [bPhase, bOrder] = [parsePhase(b.taskId), parseTaskOrder(b.taskId)];
+    if (aPhase !== bPhase) return bPhase - aPhase;
+    return bOrder - aOrder;
+  });
+  return doneTasks[0]?.complexity ?? null;
+}
+function scoreTask(task, currentPhase, completedTaskIds, allTasks, recentComplexity) {
+  const phase = parsePhase(task.taskId);
+  const reasons = [];
+  let score = 0;
+  let phaseScore = 0;
+  if (phase === currentPhase) {
+    phaseScore = 100;
+    reasons.push(`In current phase (Phase ${phase})`);
+  } else if (phase === currentPhase + 1) {
+    phaseScore = 50;
+    reasons.push(`Next phase (Phase ${phase})`);
+  } else if (phase < currentPhase) {
+    phaseScore = 100;
+    reasons.push(`Earlier incomplete phase (Phase ${phase})`);
+  }
+  score += phaseScore * 0.4;
+  const unlocksCount = countDependentTasks(task.taskId, allTasks);
+  const maxUnlocks = Math.max(
+    1,
+    ...allTasks.map((t) => countDependentTasks(t.taskId, allTasks))
+  );
+  const dependencyScore = unlocksCount / maxUnlocks * 100;
+  if (unlocksCount > 0) {
+    reasons.push(`Unlocks ${unlocksCount} other task${unlocksCount > 1 ? "s" : ""}`);
+  }
+  score += dependencyScore * 0.3;
+  let complexityScore = 50;
+  if (recentComplexity) {
+    if (recentComplexity === "High" && task.complexity !== "High") {
+      complexityScore = 100;
+      reasons.push("Good complexity balance after high-complexity task");
+    } else if (recentComplexity === "Low" && task.complexity !== "Low") {
+      complexityScore = 100;
+      reasons.push("Good complexity progression");
+    } else if (task.complexity === "Medium") {
+      complexityScore = 80;
+    }
+  } else if (task.complexity === "Low") {
+    complexityScore = 90;
+    reasons.push("Quick win opportunity");
+  }
+  score += complexityScore * 0.2;
+  const taskOrder = parseTaskOrder(task.taskId);
+  const flowScore = Math.max(0, 100 - taskOrder * 10);
+  if (taskOrder <= 2) {
+    reasons.push("Sequential task order");
+  }
+  score += flowScore * 0.1;
+  return {
+    id: task.id,
+    taskId: task.taskId,
+    name: task.name,
+    status: task.status,
+    complexity: task.complexity,
+    estimatedHours: task.estimatedHours,
+    dependencies: task.dependencies,
+    description: task.description,
+    phase,
+    score,
+    reasons,
+    unlocksCount
+  };
+}
+var taskNextTool = {
+  name: "planflow_task_next",
+  description: `Get an intelligent recommendation for the next task to work on.
+
+Analyzes project tasks and recommends the best next task based on:
+- Dependencies (prioritizes tasks that unlock others)
+- Phase progression (completes earlier phases first)
+- Complexity balance (prevents burnout, maintains momentum)
+- Sequential order (natural task flow)
+
+Usage:
+  planflow_task_next(projectId: "uuid")
+
+Parameters:
+  - projectId (required): The project UUID (get from planflow_projects)
+
+Returns:
+  - Recommended task with details
+  - Reasoning for the recommendation
+  - Alternative tasks if the main recommendation doesn't fit
+  - Project progress overview
+
+You must be logged in first with planflow_login.`,
+  inputSchema: TaskNextInputSchema,
+  async execute(input) {
+    logger.info("Finding next task recommendation", { projectId: input.projectId });
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    try {
+      const client = getApiClient();
+      const response = await client.listTasks(input.projectId);
+      logger.info("Successfully retrieved tasks for analysis", {
+        projectId: input.projectId,
+        count: response.tasks.length
+      });
+      const tasks = response.tasks;
+      if (tasks.length === 0) {
+        return createSuccessResult(
+          `\u{1F4CB} No tasks found in project "${response.projectName}".
+
+\u{1F4A1} Tasks are created when you sync your PROJECT_PLAN.md:
+  planflow_sync(projectId: "${input.projectId}", direction: "push")`
+        );
+      }
+      const completedTaskIds = new Set(
+        tasks.filter((t) => t.status === "DONE").map((t) => t.taskId)
+      );
+      const currentPhase = findCurrentPhase(tasks);
+      const recentComplexity = getRecentComplexity(tasks);
+      const availableTasks = tasks.filter(
+        (task) => task.status === "TODO" && areDependenciesSatisfied(task.dependencies, completedTaskIds)
+      );
+      const inProgressTasks = tasks.filter((t) => t.status === "IN_PROGRESS");
+      const blockedTasks = tasks.filter((t) => t.status === "BLOCKED");
+      const stats = {
+        total: tasks.length,
+        done: tasks.filter((t) => t.status === "DONE").length,
+        inProgress: inProgressTasks.length,
+        blocked: blockedTasks.length,
+        todo: tasks.filter((t) => t.status === "TODO").length
+      };
+      const progressPercent = Math.round(stats.done / stats.total * 100);
+      const progressBarLength = 10;
+      const filledBlocks = Math.floor(progressPercent / 10);
+      const progressBar = "\u{1F7E9}".repeat(filledBlocks) + "\u2B1C".repeat(progressBarLength - filledBlocks);
+      if (stats.done === stats.total) {
+        return createSuccessResult(
+          `\u{1F389} Congratulations! All tasks completed!
+
+\u2705 Project: ${response.projectName}
+\u{1F4CA} Progress: ${progressBar} 100%
+\u{1F3C6} ${stats.total} tasks completed
+
+Project Status: \u2705 COMPLETE
+
+\u{1F3AF} What's next?
+  \u2022 Deploy to production (if not already)
+  \u2022 Write post-mortem / lessons learned
+  \u2022 Gather user feedback
+  \u2022 Plan next version/features
+  \u2022 Celebrate your success! \u{1F38A}
+
+Great work on completing this project! \u{1F680}`
+        );
+      }
+      if (availableTasks.length === 0) {
+        let output2 = `\u26A0\uFE0F No tasks currently available to start.
+
+\u{1F4CA} Project Status:
+  ${progressBar} ${progressPercent}%
+  \u2705 Completed: ${stats.done}/${stats.total}
+  \u{1F504} In Progress: ${stats.inProgress}
+  \u{1F6AB} Blocked: ${stats.blocked}
+  \u23F3 Waiting on Dependencies: ${stats.todo - availableTasks.length}
+`;
+        if (inProgressTasks.length > 0) {
+          output2 += `
+\u{1F504} Tasks In Progress:
+`;
+          for (const task of inProgressTasks) {
+            output2 += `  \u2022 ${task.taskId}: ${task.name}
+`;
+          }
+        }
+        if (blockedTasks.length > 0) {
+          output2 += `
+\u{1F6AB} Blocked Tasks:
+`;
+          for (const task of blockedTasks) {
+            output2 += `  \u2022 ${task.taskId}: ${task.name}
+`;
+          }
+        }
+        output2 += `
+\u{1F4A1} Suggested Actions:
+  1. Complete in-progress tasks
+  2. Resolve blockers on blocked tasks
+  3. Review dependencies if tasks seem stuck
+
+\u{1F4A1} Commands:
+  \u2022 planflow_task_list(projectId: "${input.projectId}", status: "IN_PROGRESS")
+  \u2022 planflow_task_update(projectId: "${input.projectId}", taskId: "TX.Y", status: "DONE")`;
+        return createSuccessResult(output2);
+      }
+      const scoredTasks = availableTasks.map(
+        (task) => scoreTask(task, currentPhase, completedTaskIds, tasks, recentComplexity)
+      ).sort((a, b) => b.score - a.score);
+      const recommended = scoredTasks[0];
+      const alternatives = scoredTasks.slice(1, 4);
+      let inProgressWarning = "";
+      if (inProgressTasks.length >= 3) {
+        inProgressWarning = `\u26A0\uFE0F You have ${inProgressTasks.length} tasks in progress.
+
+\u{1F4A1} Tip: Consider finishing in-progress tasks before starting new ones:
+`;
+        for (const task of inProgressTasks.slice(0, 3)) {
+          inProgressWarning += `  \u2022 ${task.taskId}: ${task.name}
+`;
+        }
+        inProgressWarning += `
+Benefits of finishing first:
+  \u2022 Clear sense of progress
+  \u2022 Unlock dependent tasks
+  \u2022 Maintain focus and momentum
+
+${"\u2500".repeat(60)}
+
+Still want to start something new? Here's the recommendation:
+
+`;
+      }
+      const complexityIndicator = getComplexityIndicator3(recommended.complexity);
+      let output = inProgressWarning + `\u{1F3AF} Recommended Next Task
+
+${recommended.taskId}: ${recommended.name}
+
+` + formatKeyValue({
+        "Complexity": `${complexityIndicator} ${recommended.complexity}`,
+        "Estimated": recommended.estimatedHours ? `${recommended.estimatedHours} hours` : "Not estimated",
+        "Phase": `${recommended.phase}`,
+        "Dependencies": recommended.dependencies.length > 0 ? `${recommended.dependencies.join(", ")} \u2705` : "None"
+      }) + `
+
+\u2705 All dependencies completed
+`;
+      if (recommended.reasons.length > 0) {
+        output += `
+\u{1F3AF} Why this task?
+`;
+        for (const reason of recommended.reasons) {
+          output += `  \u2022 ${reason}
+`;
+        }
+      }
+      if (recommended.description) {
+        output += `
+\u{1F4DD} Task Details:
+${recommended.description}
+`;
+      }
+      output += `
+${"\u2500".repeat(60)}
+
+Ready to start?
+  planflow_task_update(projectId: "${input.projectId}", taskId: "${recommended.taskId}", status: "IN_PROGRESS")
+`;
+      if (alternatives.length > 0) {
+        output += `
+${"\u2500".repeat(60)}
+
+`;
+        output += `\u{1F4A1} Alternative Tasks (if this doesn't fit):
+
+`;
+        for (let i = 0; i < alternatives.length; i++) {
+          const alt = alternatives[i];
+          const altComplexity = getComplexityIndicator3(alt.complexity);
+          output += `${i + 1}. ${alt.taskId}: ${alt.name}
+`;
+          output += `   ${altComplexity} ${alt.complexity}`;
+          if (alt.estimatedHours) {
+            output += ` \u2022 ${alt.estimatedHours}h`;
+          }
+          if (alt.unlocksCount > 0) {
+            output += ` \u2022 Unlocks ${alt.unlocksCount} task${alt.unlocksCount > 1 ? "s" : ""}`;
+          }
+          output += "\n";
+        }
+      }
+      output += `
+${"\u2500".repeat(60)}
+
+`;
+      output += `\u{1F4CA} Progress: ${progressBar} ${progressPercent}%
+`;
+      output += `Total: ${stats.total} | \u2705 ${stats.done} | \u{1F504} ${stats.inProgress} | \u{1F4CB} ${stats.todo} | \u{1F6AB} ${stats.blocked}`;
+      if (progressPercent < 25) {
+        output += `
+
+\u{1F31F} Early Stage Tips:
+  \u2022 Focus on foundation tasks
+  \u2022 Don't skip setup steps
+  \u2022 Document as you go`;
+      } else if (progressPercent >= 75) {
+        output += `
+
+\u{1F3C1} Final Sprint:
+  \u2022 Almost there!
+  \u2022 Don't rush quality
+  \u2022 Test thoroughly`;
+      }
+      logger.info("Successfully generated task recommendation", {
+        recommendedTask: recommended.taskId,
+        score: recommended.score,
+        alternativeCount: alternatives.length
+      });
+      return createSuccessResult(output);
+    } catch (error) {
+      logger.error("Failed to find next task", {
+        error: String(error),
+        projectId: input.projectId
+      });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        if (error.statusCode === 404) {
+          return createErrorResult(
+            `\u274C Project not found: ${input.projectId}
+
+Please check the project ID and try again.
+Use planflow_projects() to list your available projects.`
+          );
+        }
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to find next task: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+
+// src/tools/notifications.ts
+import { z as z11 } from "zod";
+var NotificationsInputSchema = z11.object({
+  action: z11.enum(["list", "read", "read-all"]).default("list").describe("Action to perform: list, read (mark one as read), or read-all"),
+  projectId: z11.string().uuid("Project ID must be a valid UUID").optional().describe("Filter notifications by project (optional)"),
+  notificationId: z11.string().uuid("Notification ID must be a valid UUID").optional().describe('Notification ID to mark as read (required for "read" action)'),
+  unreadOnly: z11.boolean().default(true).describe("Only show unread notifications (default: true)"),
+  limit: z11.number().int().min(1).max(100).default(20).describe("Maximum number of notifications to fetch (default: 20)")
+});
+function getTypeEmoji(type) {
+  switch (type) {
+    case "comment":
+      return "\u{1F4AC}";
+    case "status_change":
+      return "\u{1F504}";
+    case "task_assigned":
+      return "\u{1F464}";
+    case "task_blocked":
+      return "\u{1F6AB}";
+    case "task_unblocked":
+      return "\u2705";
+    case "mention":
+      return "\u{1F4E3}";
+    default:
+      return "\u{1F514}";
+  }
+}
+function formatRelativeTime(dateString) {
+  const date = new Date(dateString);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMinutes = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMinutes / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffMinutes < 1) return "just now";
+  if (diffMinutes < 60) return `${diffMinutes} min ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
+function truncate3(str, maxLength) {
+  if (!str) return "-";
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+var notificationsTool = {
+  name: "planflow_notifications",
+  description: `View and manage PlanFlow notifications.
+
+Get notified about task updates, comments, and team activities.
+
+Usage:
+  planflow_notifications()                              # List unread notifications
+  planflow_notifications(unreadOnly: false)             # List all notifications
+  planflow_notifications(projectId: "uuid")             # Filter by project
+  planflow_notifications(action: "read", notificationId: "uuid")  # Mark as read
+  planflow_notifications(action: "read-all")            # Mark all as read
+
+Parameters:
+  - action (optional): "list" (default), "read", or "read-all"
+  - projectId (optional): Filter by project UUID
+  - notificationId (required for "read"): Notification UUID to mark as read
+  - unreadOnly (optional): Only show unread (default: true)
+  - limit (optional): Max notifications to fetch (default: 20, max: 100)
+
+Notification Types:
+  - comment: Someone commented on a task
+  - status_change: Task status was updated
+  - task_assigned: You were assigned to a task
+  - task_blocked: A task was blocked
+  - task_unblocked: A task was unblocked
+  - mention: You were mentioned in a comment
+
+You must be logged in first with planflow_login.`,
+  inputSchema: NotificationsInputSchema,
+  async execute(input) {
+    logger.info("Notifications tool called", { action: input.action, projectId: input.projectId });
+    if (!isAuthenticated()) {
+      logger.debug("No active session found");
+      return createErrorResult(
+        '\u274C Not logged in.\n\nPlease authenticate first using:\n  planflow_login(token: "your-api-token")\n\nGet your token at: https://planflow.tools/settings/api-tokens'
+      );
+    }
+    try {
+      const client = getApiClient();
+      switch (input.action) {
+        case "read": {
+          if (!input.notificationId) {
+            return createErrorResult(
+              '\u274C Missing notificationId\n\nTo mark a notification as read, provide the notification ID:\n  planflow_notifications(action: "read", notificationId: "uuid")\n\nUse planflow_notifications() to list notifications and get their IDs.'
+            );
+          }
+          logger.info("Marking notification as read", { notificationId: input.notificationId });
+          const result = await client.markNotificationRead(input.notificationId);
+          return createSuccessResult(
+            `\u2705 Notification marked as read
+
+${getTypeEmoji(result.notification.type)} ${result.notification.message}
+
+\u{1F4A1} Commands:
+  \u2022 planflow_notifications() - View remaining notifications`
+          );
+        }
+        case "read-all": {
+          logger.info("Marking all notifications as read", { projectId: input.projectId });
+          const result = await client.markAllNotificationsRead(input.projectId);
+          const scopeMessage = input.projectId ? "for this project" : "across all projects";
+          return createSuccessResult(
+            `\u2705 Marked ${result.markedCount} notification${result.markedCount !== 1 ? "s" : ""} as read ${scopeMessage}
+
+\u{1F514} You're all caught up!
+
+\u{1F4A1} Commands:
+  \u2022 planflow_notifications(unreadOnly: false) - View all notifications`
+          );
+        }
+        case "list":
+        default: {
+          logger.info("Fetching notifications", {
+            projectId: input.projectId,
+            unreadOnly: input.unreadOnly,
+            limit: input.limit
+          });
+          const response = await client.listNotifications({
+            projectId: input.projectId,
+            unreadOnly: input.unreadOnly,
+            limit: input.limit
+          });
+          logger.info("Successfully retrieved notifications", {
+            count: response.notifications.length,
+            unreadCount: response.unreadCount,
+            totalCount: response.totalCount
+          });
+          if (response.notifications.length === 0) {
+            const filterMessage = input.unreadOnly ? "unread " : "";
+            const projectMessage = input.projectId ? " for this project" : "";
+            return createSuccessResult(
+              `\u{1F514} No ${filterMessage}notifications${projectMessage}
+
+` + (input.unreadOnly ? "\u2728 You're all caught up!\n\n\u{1F4A1} Commands:\n  \u2022 planflow_notifications(unreadOnly: false) - View all notifications" : "\u{1F4A1} Notifications will appear when:\n  \u2022 Someone comments on your tasks\n  \u2022 Task statuses change\n  \u2022 You're assigned to a task\n  \u2022 You're mentioned in a comment")
+            );
+          }
+          const headers = ["Type", "Message", "Project", "Task", "Time", "Read"];
+          const rows = response.notifications.map((n) => [
+            getTypeEmoji(n.type),
+            truncate3(n.message, 35),
+            truncate3(n.projectName, 15),
+            n.taskId ?? "-",
+            formatRelativeTime(n.createdAt),
+            n.read ? "\u2713" : "\u2022"
+          ]);
+          const filterLabel = input.unreadOnly ? " (unread only)" : "";
+          const projectLabel = input.projectId ? ` for project` : "";
+          const output = [
+            `\u{1F514} Notifications${filterLabel}${projectLabel}
+`,
+            `Unread: ${response.unreadCount} | Total: ${response.totalCount}
+`,
+            formatTable(headers, rows),
+            "\n\n\u{1F4A1} Commands:",
+            '  \u2022 planflow_notifications(action: "read", notificationId: "uuid") - Mark as read',
+            '  \u2022 planflow_notifications(action: "read-all") - Mark all as read',
+            input.unreadOnly ? "  \u2022 planflow_notifications(unreadOnly: false) - Show all notifications" : "  \u2022 planflow_notifications() - Show only unread"
+          ].join("\n");
+          return createSuccessResult(output);
+        }
+      }
+    } catch (error) {
+      logger.error("Failed to handle notifications", { error: String(error), action: input.action });
+      if (error instanceof AuthError) {
+        return createErrorResult(
+          '\u274C Authentication error: Your session may have expired.\n\nPlease log out and log in again:\n  1. planflow_logout()\n  2. planflow_login(token: "your-new-token")\n\nGet a new token at: https://planflow.tools/settings/api-tokens'
+        );
+      }
+      if (error instanceof ApiError) {
+        if (error.statusCode === 404) {
+          if (input.action === "read") {
+            return createErrorResult(
+              `\u274C Notification not found: ${input.notificationId}
+
+The notification may have been deleted or the ID is incorrect.
+Use planflow_notifications() to list available notifications.`
+            );
+          }
+          return createErrorResult(
+            `\u274C Resource not found
+
+Please check the project ID and try again.
+Use planflow_projects() to list your available projects.`
+          );
+        }
+        return createErrorResult(
+          `\u274C API error: ${error.message}
+
+Please check your internet connection and try again.`
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorResult(
+        `\u274C Failed to handle notifications: ${message}
+
+Please try again or check your connection.`
+      );
+    }
+  }
+};
+
+// src/tools/index.ts
+var tools = [
+  loginTool,
+  logoutTool,
+  whoamiTool,
+  projectsTool,
+  createTool,
+  syncTool,
+  taskListTool,
+  taskUpdateTool,
+  taskNextTool,
+  notificationsTool
+];
+
+// src/server.ts
+function formatErrorResponse(error) {
+  let message;
+  if (error instanceof PlanFlowError) {
+    message = `Error [${error.code}]: ${error.message}`;
+    if (error.details) {
+      message += `
+Details: ${JSON.stringify(error.details, null, 2)}`;
+    }
+  } else if (error instanceof Error) {
+    message = `Error: ${error.message}`;
+  } else {
+    message = `Error: ${String(error)}`;
+  }
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function zodToJsonSchema(schema) {
+  if ("shape" in schema && schema.shape) {
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      const zodField = value;
+      let type = "string";
+      const typeName = zodField._def?.typeName;
+      if (typeName === "ZodNumber") type = "number";
+      if (typeName === "ZodBoolean") type = "boolean";
+      if (typeName === "ZodArray") type = "array";
+      properties[key] = {
+        type,
+        description: zodField._def?.description
+      };
+      if (typeof zodField.isOptional !== "function" || !zodField.isOptional()) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0
+    };
+  }
+  return { type: "object", properties: {} };
+}
+function createServer() {
+  const server = new Server(
+    {
+      name: APP_NAME,
+      version: APP_VERSION
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logger.debug("Listing tools", { count: tools.length });
+    return {
+      tools: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: zodToJsonSchema(tool.inputSchema)
+      }))
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    logger.info("Tool called", { name });
+    const tool = tools.find((t) => t.name === name);
+    if (!tool) {
+      logger.warn("Unknown tool requested", { name });
+      return formatErrorResponse(new ToolError(`Unknown tool: ${name}`, name));
+    }
+    try {
+      const parseResult = tool.inputSchema.safeParse(args);
+      if (!parseResult.success) {
+        logger.warn("Tool input validation failed", {
+          name,
+          errors: parseResult.error.errors
+        });
+        return formatErrorResponse(
+          new PlanFlowError(
+            `Invalid input: ${parseResult.error.errors.map((e) => e.message).join(", ")}`,
+            "VALIDATION_ERROR",
+            { errors: parseResult.error.errors }
+          )
+        );
+      }
+      const result = await tool.execute(parseResult.data);
+      logger.debug("Tool executed successfully", { name });
+      return result;
+    } catch (error) {
+      logger.error("Tool execution failed", {
+        name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return formatErrorResponse(error);
+    }
+  });
+  return server;
+}
+async function startServer() {
+  logger.info("Starting PlanFlow MCP Server", { version: APP_VERSION });
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  server.onerror = (error) => {
+    logger.error("Server error", { error: String(error) });
+  };
+  const shutdown = async () => {
+    logger.info("Shutting down server...");
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await server.connect(transport);
+  logger.info("Server connected and ready");
+}
+
+// src/index.ts
+if (process.env["PLANFLOW_DEBUG"] === "true") {
+  logger.setLevel("debug");
+}
+startServer().catch((error) => {
+  logger.error("Failed to start server", {
+    error: error instanceof Error ? error.message : String(error)
+  });
+  process.exit(1);
+});