clickup-agent-cli 0.2.0

package/dist/clickup.js

@@ -0,0 +1,4034 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+function parseApiError(responseBody, status) {
+  let message = `API request failed with status ${status}`;
+  let ecode;
+  if (responseBody && typeof responseBody === "object") {
+    const body = responseBody;
+    if (typeof body["ECODE"] === "string") {
+      ecode = body["ECODE"];
+    }
+    if (typeof body["err"] === "string") {
+      message = body["err"];
+    }
+  }
+  if (ecode && ECODE_MESSAGES[ecode]) {
+    message = ECODE_MESSAGES[ecode];
+  } else if (!ecode && STATUS_MESSAGES[status]) {
+    message = STATUS_MESSAGES[status];
+  }
+  return new ClickUpError(message, status, ecode, responseBody);
+}
+function mapToExitCode(error) {
+  if (!(error instanceof ClickUpError)) {
+    return 1;
+  }
+  switch (error.status) {
+    case 401:
+      return 3;
+    case 403:
+      return 5;
+    case 404:
+      return 4;
+    case 429:
+      return 6;
+    default:
+      if (error.status >= 500) return 1;
+      return 1;
+  }
+}
+var ClickUpError, ECODE_MESSAGES, STATUS_MESSAGES, EXIT_CODES;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    ClickUpError = class extends Error {
+      status;
+      ecode;
+      body;
+      constructor(message, status, ecode, body) {
+        super(message);
+        this.name = "ClickUpError";
+        this.status = status;
+        this.ecode = ecode;
+        this.body = body;
+      }
+    };
+    ECODE_MESSAGES = {
+      OAUTH_023: "Invalid or expired token. Run: clickup auth login",
+      OAUTH_024: "Token does not have permission for this action.",
+      ITEM_015: "Task not found. Check the task ID.",
+      TEAM_015: "Workspace not found. Check the workspace ID or run: clickup config set workspace_id <id>"
+    };
+    STATUS_MESSAGES = {
+      401: "Authentication failed. Run: clickup auth login",
+      403: "Permission denied. Check your access level in ClickUp.",
+      404: "Resource not found. Verify the ID.",
+      429: "Rate limited. Retrying automatically..."
+    };
+    EXIT_CODES = {
+      SUCCESS: 0,
+      GENERAL_ERROR: 1,
+      INVALID_ARGS: 2,
+      AUTH_FAILURE: 3,
+      NOT_FOUND: 4,
+      PERMISSION_DENIED: 5,
+      RATE_LIMITED: 6,
+      NETWORK_ERROR: 7
+    };
+  }
+});
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  ClickUpClient: () => ClickUpClient
+});
+import { readFileSync } from "fs";
+import { basename } from "path";
+var DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY, DEFAULT_TIMEOUT, RETRYABLE_STATUSES, NON_RETRYABLE_STATUSES, ClickUpClient;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    init_errors();
+    DEFAULT_BASE_URL = "https://api.clickup.com/api/v2";
+    DEFAULT_MAX_RETRIES = 3;
+    DEFAULT_RETRY_DELAY = 1e3;
+    DEFAULT_TIMEOUT = 3e4;
+    RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+    NON_RETRYABLE_STATUSES = /* @__PURE__ */ new Set([400, 401, 403, 404, 422]);
+    ClickUpClient = class {
+      token;
+      baseUrl;
+      maxRetries;
+      retryDelay;
+      timeout;
+      verbose;
+      debug;
+      dryRun;
+      constructor(options) {
+        this.token = options.token;
+        this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.retryDelay = options.retryDelay ?? DEFAULT_RETRY_DELAY;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+        this.verbose = options.verbose ?? false;
+        this.debug = options.debug ?? false;
+        this.dryRun = options.dryRun ?? false;
+      }
+      async get(path, params) {
+        return this.request("GET", path, void 0, params);
+      }
+      async post(path, body) {
+        return this.request("POST", path, body);
+      }
+      async put(path, body) {
+        return this.request("PUT", path, body);
+      }
+      async patch(path, body) {
+        return this.request("PATCH", path, body);
+      }
+      async delete(path, body) {
+        return this.request("DELETE", path, body);
+      }
+      async upload(path, filePath, filename) {
+        const fileBuffer = readFileSync(filePath);
+        const resolvedFilename = filename ?? basename(filePath);
+        const formData = new FormData();
+        formData.append("attachment", new Blob([fileBuffer]), resolvedFilename);
+        const url = `${this.baseUrl}${path}`;
+        if (this.dryRun) {
+          this.logDryRun("POST", url, "[multipart form data]");
+          return {};
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: { Authorization: this.token },
+            body: formData,
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            const body = await this.safeJson(response);
+            throw parseApiError(body, response.status);
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error instanceof ClickUpError) throw error;
+          throw new ClickUpError(
+            `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
+            0,
+            void 0,
+            void 0
+          );
+        }
+      }
+      async request(method, path, body, params) {
+        let url = this.resolveUrl(path);
+        if (params) {
+          const searchParams = new URLSearchParams();
+          for (const [key, value] of Object.entries(params)) {
+            if (value === void 0) continue;
+            if (Array.isArray(value)) {
+              for (const v of value) searchParams.append(key, v);
+            } else {
+              searchParams.set(key, value);
+            }
+          }
+          const qs = searchParams.toString();
+          if (qs) url = `${url}?${qs}`;
+        }
+        if (this.dryRun) {
+          this.logDryRun(method, url, body);
+          return {};
+        }
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          if (attempt > 0) {
+            const delay = this.retryDelay * Math.pow(2, attempt - 1);
+            if (this.verbose || this.debug) {
+              process.stderr.write(`Retrying in ${delay}ms (attempt ${attempt + 1}/${this.maxRetries + 1})...
+`);
+            }
+            await this.sleep(delay);
+          }
+          const start = Date.now();
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+          try {
+            const headers = {
+              Authorization: this.token
+            };
+            if (body !== void 0) {
+              headers["Content-Type"] = "application/json";
+            }
+            if (this.debug) {
+              const redactedHeaders = { ...headers, Authorization: "<redacted>" };
+              process.stderr.write(`[${method}] ${url}
+Headers: ${JSON.stringify(redactedHeaders)}
+`);
+              if (body !== void 0) {
+                process.stderr.write(`Body: ${JSON.stringify(body, null, 2)}
+`);
+              }
+            }
+            const fetchInit = {
+              method,
+              headers,
+              signal: controller.signal
+            };
+            if (body !== void 0) {
+              fetchInit.body = JSON.stringify(body);
+            }
+            const response = await fetch(url, fetchInit);
+            clearTimeout(timeoutId);
+            const elapsed = Date.now() - start;
+            if (this.verbose || this.debug) {
+              process.stderr.write(`[${method}] ${path} ${response.status} ${response.statusText} (${elapsed}ms)
+`);
+            }
+            const remaining = response.headers.get("X-RateLimit-Remaining");
+            const reset = response.headers.get("X-RateLimit-Reset");
+            if (remaining === "0" && reset) {
+              const resetTime = parseInt(reset, 10) * 1e3;
+              const waitMs = Math.max(0, resetTime - Date.now());
+              if (waitMs > 0) {
+                process.stderr.write(`Rate limited. Waiting ${Math.ceil(waitMs / 1e3)}s...
+`);
+                await this.sleep(waitMs);
+              }
+            }
+            if (!response.ok) {
+              const responseBody = await this.safeJson(response);
+              const error = parseApiError(responseBody, response.status);
+              if (this.debug) {
+                process.stderr.write(`Error response: ${JSON.stringify(responseBody, null, 2)}
+`);
+              }
+              if (NON_RETRYABLE_STATUSES.has(response.status)) {
+                throw error;
+              }
+              if (RETRYABLE_STATUSES.has(response.status) && attempt < this.maxRetries) {
+                lastError = error;
+                continue;
+              }
+              throw error;
+            }
+            const responseData = await this.safeJson(response);
+            if (this.debug) {
+              process.stderr.write(`Response: ${JSON.stringify(responseData, null, 2)}
+`);
+            }
+            return responseData;
+          } catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof ClickUpError) {
+              if (NON_RETRYABLE_STATUSES.has(error.status)) throw error;
+              if (attempt >= this.maxRetries) throw error;
+              lastError = error;
+              continue;
+            }
+            if (error instanceof DOMException && error.name === "AbortError") {
+              throw new ClickUpError("Request timed out", 0, void 0, void 0);
+            }
+            throw new ClickUpError(
+              `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
+              0,
+              void 0,
+              void 0
+            );
+          }
+        }
+        throw lastError ?? new ClickUpError("Request failed after retries", 0, void 0, void 0);
+      }
+      resolveUrl(path) {
+        if (path.startsWith("/v3/")) {
+          const origin = new URL(this.baseUrl).origin;
+          return `${origin}/api${path}`;
+        }
+        return `${this.baseUrl}${path}`;
+      }
+      logDryRun(method, url, body) {
+        process.stderr.write(`[DRY RUN] ${method} ${url}
+`);
+        if (body !== void 0 && body !== "[multipart form data]") {
+          process.stderr.write(`Body: ${JSON.stringify(body, null, 2)}
+`);
+        }
+        if (body === "[multipart form data]") {
+          process.stderr.write(`Body: ${body}
+`);
+        }
+      }
+      async safeJson(response) {
+        try {
+          return await response.json();
+        } catch {
+          return null;
+        }
+      }
+      sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+    };
+  }
+});
+
+// src/config.ts
+import Conf from "conf";
+function isValidConfigKey(key) {
+  return CONFIG_KEYS.includes(key);
+}
+function resolveString(key, flagValue) {
+  if (flagValue !== void 0) return flagValue;
+  const envVal = process.env[ENV_MAP[key]];
+  if (envVal !== void 0) return envVal;
+  const stored = config.get(key);
+  if (typeof stored === "string") return stored;
+  return void 0;
+}
+function resolveToken(flagValue) {
+  return resolveString("token", flagValue);
+}
+function resolveWorkspaceId(flagValue) {
+  return resolveString("workspace_id", flagValue);
+}
+function resolveOutputFormat(flagValue) {
+  const val = resolveString("output_format", flagValue);
+  if (val) return val;
+  return process.stdout.isTTY ? "table" : "json";
+}
+var CONFIG_KEYS, VALID_CONFIG_KEYS, config, ENV_MAP;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    CONFIG_KEYS = ["token", "workspace_id", "output_format", "color", "page_size", "timezone"];
+    VALID_CONFIG_KEYS = CONFIG_KEYS;
+    config = new Conf({
+      projectName: "clickup-cli",
+      schema: {
+        token: { type: "string" },
+        workspace_id: { type: "string" },
+        output_format: { type: "string", enum: ["table", "json", "csv", "tsv", "quiet", "id"] },
+        color: { type: "boolean", default: true },
+        page_size: { type: "number", default: 100 },
+        timezone: { type: "string" }
+      }
+    });
+    ENV_MAP = {
+      token: "CLICKUP_API_TOKEN",
+      workspace_id: "CLICKUP_WORKSPACE_ID",
+      output_format: "CLICKUP_OUTPUT_FORMAT",
+      color: "CLICKUP_COLOR",
+      page_size: "CLICKUP_PAGE_SIZE",
+      timezone: "CLICKUP_TIMEZONE"
+    };
+  }
+});
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  generateCodeChallenge: () => generateCodeChallenge,
+  generateCodeVerifier: () => generateCodeVerifier,
+  oauthLogin: () => oauthLogin
+});
+import { createServer } from "http";
+import { randomBytes, createHash } from "crypto";
+function generateCodeVerifier() {
+  return randomBytes(48).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function buildAuthorizeUrl(clientId, codeChallenge) {
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: REDIRECT_URI,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  });
+  return `${CLICKUP_AUTHORIZE_URL}?${params.toString()}`;
+}
+async function exchangeCodeForToken(code, clientId, clientSecret, codeVerifier) {
+  const response = await fetch(CLICKUP_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      client_id: clientId,
+      client_secret: clientSecret,
+      code,
+      code_verifier: codeVerifier
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Token exchange failed (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  const token = data["access_token"];
+  if (typeof token !== "string" || !token) {
+    throw new Error("No access_token in token exchange response");
+  }
+  return token;
+}
+function waitForCallback(server) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("OAuth callback timed out after 120 seconds"));
+    }, 12e4);
+    server.on("request", (req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+      if (url.pathname !== CALLBACK_PATH) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end("<html><body><h1>Authentication failed</h1><p>You can close this tab.</p></body></html>");
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error(`OAuth error: ${error}`));
+        return;
+      }
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h1>Missing code</h1><p>No authorization code received.</p></body></html>");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end("<html><body><h1>Authenticated</h1><p>You can close this tab and return to the terminal.</p></body></html>");
+      clearTimeout(timeout);
+      server.close();
+      resolve(code);
+    });
+  });
+}
+async function openBrowser(url) {
+  const { platform } = process;
+  let command;
+  if (platform === "darwin") {
+    command = "open";
+  } else if (platform === "win32") {
+    command = "start";
+  } else {
+    command = "xdg-open";
+  }
+  const { exec } = await import("child_process");
+  return new Promise((resolve) => {
+    exec(`${command} "${url}"`, () => {
+      resolve();
+    });
+  });
+}
+async function oauthLogin() {
+  const clientId = process.env["CLICKUP_CLIENT_ID"];
+  const clientSecret = process.env["CLICKUP_CLIENT_SECRET"];
+  if (!clientId) {
+    process.stderr.write("Error: CLICKUP_CLIENT_ID environment variable is required for OAuth.\n");
+    process.exit(2);
+    throw new Error("unreachable");
+  }
+  if (!clientSecret) {
+    process.stderr.write("Error: CLICKUP_CLIENT_SECRET environment variable is required for OAuth.\n");
+    process.exit(2);
+    throw new Error("unreachable");
+  }
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const server = createServer();
+  await new Promise((resolve, reject) => {
+    server.listen(CALLBACK_PORT, () => resolve());
+    server.on("error", reject);
+  });
+  const authorizeUrl = buildAuthorizeUrl(clientId, codeChallenge);
+  process.stderr.write(`Opening browser for authentication...
+`);
+  process.stderr.write(`If the browser does not open, visit:
+${authorizeUrl}
+`);
+  await openBrowser(authorizeUrl);
+  const code = await waitForCallback(server);
+  process.stderr.write("Exchanging code for token...\n");
+  const token = await exchangeCodeForToken(code, clientId, clientSecret, codeVerifier);
+  config.set("token", token);
+  return token;
+}
+var CLICKUP_AUTHORIZE_URL, CLICKUP_TOKEN_URL, CALLBACK_PORT, CALLBACK_PATH, REDIRECT_URI;
+var init_auth = __esm({
+  "src/auth.ts"() {
+    "use strict";
+    init_config();
+    CLICKUP_AUTHORIZE_URL = "https://app.clickup.com/api";
+    CLICKUP_TOKEN_URL = "https://api.clickup.com/api/v2/oauth/token";
+    CALLBACK_PORT = 9876;
+    CALLBACK_PATH = "/callback";
+    REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+  }
+});
+
+// src/cli.ts
+init_client();
+init_errors();
+init_config();
+import { Command } from "commander";
+
+// src/commands/auth-cmd.ts
+init_config();
+function registerAuthCommands(program, getClient) {
+  const auth = program.command("auth").description("Manage authentication");
+  auth.command("login").description("Authenticate with ClickUp").option("--token <token>", "Personal API token").option("--oauth", "Use OAuth2 PKCE browser flow (requires CLICKUP_CLIENT_ID and CLICKUP_CLIENT_SECRET)").action(async (opts) => {
+    if (opts.oauth) {
+      const { oauthLogin: oauthLogin2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+      const token2 = await oauthLogin2();
+      const { ClickUpClient: ClientClass2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+      const client2 = new ClientClass2({ token: token2 });
+      try {
+        const userData = await client2.get("/user");
+        process.stdout.write(`Authenticated as ${userData.user.username} (${userData.user.email})
+`);
+      } catch {
+        process.stderr.write("Warning: Token obtained but validation failed.\n");
+      }
+      return;
+    }
+    let token = opts.token;
+    if (!token) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: No token provided. Use --token <token> or --oauth in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { password } = await import("@inquirer/prompts");
+      token = await password({
+        message: "Enter your ClickUp API token:",
+        mask: "*"
+      });
+    }
+    if (!token) {
+      process.stderr.write("Error: No token provided.\n");
+      process.exit(2);
+      return;
+    }
+    const { ClickUpClient: ClientClass } = await Promise.resolve().then(() => (init_client(), client_exports));
+    const client = new ClientClass({ token });
+    try {
+      const userData = await client.get("/user");
+      config.set("token", token);
+      process.stdout.write(`Authenticated as ${userData.user.username} (${userData.user.email})
+`);
+    } catch {
+      process.stderr.write("Error: Invalid token. Authentication failed.\n");
+      process.exit(3);
+    }
+  });
+  auth.command("logout").description("Remove stored credentials").action(() => {
+    config.delete("token");
+    process.stdout.write("Logged out. Token removed.\n");
+  });
+  auth.command("status").description("Show current authentication state").action(async () => {
+    const token = resolveToken();
+    if (!token) {
+      process.stdout.write("Not authenticated. Run: clickup auth login\n");
+      return;
+    }
+    const prefix = token.slice(0, 8);
+    process.stdout.write(`Token: ${prefix}...
+`);
+    const workspaceId = config.get("workspace_id");
+    if (workspaceId) {
+      process.stdout.write(`Workspace: ${workspaceId}
+`);
+    }
+    try {
+      const client = getClient();
+      const userData = await client.get("/user");
+      process.stdout.write(`User: ${userData.user.username} (${userData.user.email})
+`);
+      process.stdout.write("Status: Valid\n");
+    } catch {
+      process.stdout.write("Status: Invalid or expired\n");
+    }
+  });
+  auth.command("token").description("Print current token to stdout").action(() => {
+    const token = resolveToken();
+    if (!token) {
+      process.stderr.write("Error: No token found. Run: clickup auth login\n");
+      process.exit(3);
+      return;
+    }
+    process.stdout.write(token + "\n");
+  });
+}
+
+// src/commands/config-cmd.ts
+init_config();
+function registerConfigCommands(program) {
+  const configCmd = program.command("config").description("Manage CLI configuration");
+  configCmd.command("set").description("Set a configuration value").argument("<key>", "Config key").argument("<value>", "Config value").action((key, value) => {
+    if (!isValidConfigKey(key)) {
+      process.stderr.write(`Error: Unknown config key "${key}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}
+`);
+      process.exit(2);
+      return;
+    }
+    if (key === "color") {
+      config.set(key, value === "true" || value === "1");
+    } else if (key === "page_size") {
+      const num = parseInt(value, 10);
+      if (isNaN(num) || num <= 0) {
+        process.stderr.write("Error: page_size must be a positive number.\n");
+        process.exit(2);
+        return;
+      }
+      config.set(key, num);
+    } else {
+      config.set(key, value);
+    }
+    process.stdout.write(`Set ${key} = ${value}
+`);
+  });
+  configCmd.command("get").description("Get a configuration value").argument("<key>", "Config key").action((key) => {
+    if (!isValidConfigKey(key)) {
+      process.stderr.write(`Error: Unknown config key "${key}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}
+`);
+      process.exit(2);
+      return;
+    }
+    const value = config.get(key);
+    if (value === void 0) {
+      process.stdout.write("(not set)\n");
+    } else {
+      process.stdout.write(`${value}
+`);
+    }
+  });
+  configCmd.command("list").description("List all configuration values").action(() => {
+    const store = config.store;
+    const keys = VALID_CONFIG_KEYS;
+    for (const key of keys) {
+      const value = store[key];
+      if (value !== void 0) {
+        process.stdout.write(`${key} = ${value}
+`);
+      }
+    }
+  });
+  configCmd.command("reset").description("Reset all configuration to defaults").option("--confirm", "Skip confirmation prompt").action(async (opts) => {
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Add --confirm to proceed with this destructive action.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const answer = await confirm({
+        message: "Reset all configuration to defaults?",
+        default: false
+      });
+      if (!answer) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    config.clear();
+    process.stdout.write("Configuration reset to defaults.\n");
+  });
+  configCmd.command("path").description("Print the config file path").action(() => {
+    process.stdout.write(config.path + "\n");
+  });
+}
+
+// src/commands/workspace.ts
+init_config();
+
+// src/output.ts
+import Table from "cli-table3";
+function formatOutput(data, columns, opts) {
+  const rows = Array.isArray(data) ? data : [data];
+  let processed = applyFilter(rows, opts.filter);
+  processed = applySort(processed, opts.sort);
+  if (opts.limit !== void 0 && opts.limit > 0) {
+    processed = processed.slice(0, opts.limit);
+  }
+  const activeCols = filterColumns(columns, opts.fields);
+  const format = opts.format ?? (process.stdout.isTTY ? "table" : "json");
+  switch (format) {
+    case "table":
+      printTable(processed, activeCols, opts);
+      break;
+    case "json":
+      printJson(processed);
+      break;
+    case "csv":
+      printDelimited(processed, activeCols, ",", opts);
+      break;
+    case "tsv":
+      printDelimited(processed, activeCols, "	", opts);
+      break;
+    case "quiet":
+      printQuiet(processed);
+      break;
+    case "id":
+      printId(processed);
+      break;
+    case "md":
+      printMarkdown(processed, activeCols, opts);
+      break;
+    default:
+      printJson(processed);
+  }
+}
+function filterColumns(columns, fields) {
+  if (!fields) return columns;
+  const wanted = new Set(fields.split(",").map((f) => f.trim()));
+  return columns.filter((c) => wanted.has(c.key));
+}
+function applyFilter(rows, filter) {
+  if (!filter) return rows;
+  const eqIndex = filter.indexOf("=");
+  if (eqIndex === -1) return rows;
+  const key = filter.slice(0, eqIndex);
+  const value = filter.slice(eqIndex + 1);
+  return rows.filter((row) => {
+    if (row && typeof row === "object") {
+      const record = row;
+      return String(record[key] ?? "") === value;
+    }
+    return false;
+  });
+}
+function applySort(rows, sort) {
+  if (!sort) return rows;
+  const parts = sort.split(":");
+  const field = parts[0];
+  const desc = parts[1] === "desc";
+  return [...rows].sort((a, b) => {
+    const aObj = a;
+    const bObj = b;
+    const aVal = aObj[field];
+    const bVal = bObj[field];
+    if (aVal === bVal) return 0;
+    if (aVal === void 0 || aVal === null) return 1;
+    if (bVal === void 0 || bVal === null) return -1;
+    const result = String(aVal).localeCompare(String(bVal), void 0, { numeric: true });
+    return desc ? -result : result;
+  });
+}
+function getValue(row, key) {
+  if (row && typeof row === "object") {
+    const record = row;
+    const val = record[key];
+    if (val === null || val === void 0) return "";
+    if (typeof val === "object") return JSON.stringify(val);
+    return String(val);
+  }
+  return "";
+}
+function truncate(str, width) {
+  if (str.length <= width) return str;
+  return str.slice(0, width - 3) + "...";
+}
+function printTable(rows, columns, opts) {
+  if (columns.length === 0) {
+    printJson(rows);
+    return;
+  }
+  const tableOpts = {
+    colWidths: columns.map((c) => c.width),
+    style: { head: opts.noColor ? [] : ["cyan"] }
+  };
+  if (!opts.noHeader) {
+    tableOpts["head"] = columns.map((c) => c.header);
+  }
+  const table = new Table(tableOpts);
+  for (const row of rows) {
+    table.push(columns.map((col) => truncate(getValue(row, col.key), col.width - 2)));
+  }
+  process.stdout.write(table.toString() + "\n");
+}
+function printJson(rows) {
+  process.stdout.write(JSON.stringify(rows.length === 1 ? rows[0] : rows, null, 2) + "\n");
+}
+function printDelimited(rows, columns, delimiter, opts) {
+  if (!opts.noHeader) {
+    process.stdout.write(columns.map((c) => c.header).join(delimiter) + "\n");
+  }
+  for (const row of rows) {
+    const values = columns.map((col) => {
+      const val = getValue(row, col.key);
+      if (delimiter === "," && (val.includes(",") || val.includes('"') || val.includes("\n"))) {
+        return `"${val.replace(/"/g, '""')}"`;
+      }
+      return val;
+    });
+    process.stdout.write(values.join(delimiter) + "\n");
+  }
+}
+function printQuiet(rows) {
+  for (const row of rows) {
+    const id = getValue(row, "id");
+    if (id) process.stdout.write(id + "\n");
+  }
+}
+function printId(rows) {
+  if (rows.length > 0) {
+    const id = getValue(rows[0], "id");
+    if (id) process.stdout.write(id + "\n");
+  }
+}
+function printMarkdown(rows, columns, opts) {
+  if (columns.length === 0) {
+    printJson(rows);
+    return;
+  }
+  if (!opts.noHeader) {
+    process.stdout.write("| " + columns.map((c) => c.header).join(" | ") + " |\n");
+    process.stdout.write("| " + columns.map((c) => "-".repeat(Math.max(c.header.length, 3))).join(" | ") + " |\n");
+  }
+  for (const row of rows) {
+    process.stdout.write("| " + columns.map((col) => getValue(row, col.key).replace(/\|/g, "\\|")).join(" | ") + " |\n");
+  }
+}
+
+// src/schema.ts
+var registry = /* @__PURE__ */ new Map();
+function registerSchema(resource, action, description, fields) {
+  if (!registry.has(resource)) {
+    registry.set(resource, /* @__PURE__ */ new Map());
+  }
+  registry.get(resource).set(action, { action, description, fields });
+}
+function getResources() {
+  return Array.from(registry.keys()).sort();
+}
+function getActions(resource) {
+  const actions = registry.get(resource);
+  if (!actions) return void 0;
+  return Array.from(actions.values());
+}
+function getFields(resource, action) {
+  return registry.get(resource)?.get(action);
+}
+
+// src/commands/workspace.ts
+registerSchema("workspace", "list", "List all workspaces accessible to the authenticated user", []);
+registerSchema("workspace", "get", "Get workspace details", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+registerSchema("workspace", "seats", "Show seat usage for a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+registerSchema("workspace", "plan", "Show current billing plan for a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+registerSchema("workspace", "members", "List all members in a workspace", [
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID" }
+]);
+var WORKSPACE_MEMBER_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "username", header: "Username", width: 22 },
+  { key: "email", header: "Email", width: 32 },
+  { key: "role", header: "Role", width: 10 }
+];
+var WORKSPACE_COLUMNS = [
+  { key: "id", header: "ID", width: 14 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "color", header: "Color", width: 10 },
+  { key: "member_count", header: "Members", width: 10 }
+];
+var SEAT_COLUMNS = [
+  { key: "type", header: "Type", width: 12 },
+  { key: "filled", header: "Filled", width: 10 },
+  { key: "total", header: "Total", width: 10 },
+  { key: "empty", header: "Empty", width: 10 }
+];
+function requireWorkspaceId(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function registerWorkspaceCommands(program, getClient) {
+  const workspace = program.command("workspace").description("Manage workspaces");
+  workspace.command("list").description("List all workspaces").action(async () => {
+    const client = getClient();
+    const data = await client.get("/team");
+    const rows = data.teams.map((t) => ({
+      ...t,
+      member_count: t.members?.length ?? 0
+    }));
+    formatOutput(rows, WORKSPACE_COLUMNS, getOutputOptions(program));
+  });
+  workspace.command("get").description("Get workspace details").action(async () => {
+    const workspaceId = requireWorkspaceId(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}`);
+    const row = {
+      ...data.team,
+      member_count: Array.isArray(data.team["members"]) ? data.team["members"].length : 0
+    };
+    formatOutput(row, WORKSPACE_COLUMNS, getOutputOptions(program));
+  });
+  workspace.command("seats").description("Show seat usage").action(async () => {
+    const workspaceId = requireWorkspaceId(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/seats`);
+    const rows = [];
+    if (data.members) {
+      rows.push({
+        type: "Members",
+        filled: data.members.filled_members_count ?? 0,
+        total: data.members.total_member_seats ?? 0,
+        empty: data.members.empty_member_seats ?? 0
+      });
+    }
+    if (data.guests) {
+      rows.push({
+        type: "Guests",
+        filled: data.guests.filled_guest_count ?? 0,
+        total: data.guests.total_guest_seats ?? 0,
+        empty: data.guests.empty_guest_seats ?? 0
+      });
+    }
+    formatOutput(rows, SEAT_COLUMNS, getOutputOptions(program));
+  });
+  workspace.command("plan").description("Show current billing plan").action(async () => {
+    const workspaceId = requireWorkspaceId(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/plan`);
+    formatOutput(data, [
+      { key: "plan_id", header: "Plan ID", width: 12 },
+      { key: "plan_name", header: "Plan", width: 30 }
+    ], getOutputOptions(program));
+  });
+  workspace.command("members").description("List all members in workspace").action(async () => {
+    const workspaceId = requireWorkspaceId(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(
+      `/team/${workspaceId}/member`
+    );
+    const rows = (data.members ?? []).map((m) => ({
+      id: m.user["id"],
+      username: m.user["username"],
+      email: m.user["email"],
+      role: m.role
+    }));
+    formatOutput(rows, WORKSPACE_MEMBER_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/space.ts
+init_config();
+registerSchema("space", "list", "List spaces in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--archived", type: "boolean", required: false, description: "Include archived spaces" }
+]);
+registerSchema("space", "get", "Get space details", [
+  { flag: "<space-id>", type: "string", required: true, description: "Space ID" }
+]);
+registerSchema("space", "create", "Create a new space", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--name", type: "string", required: true, description: "Space name" },
+  { flag: "--multiple-assignees", type: "boolean", required: false, description: "Enable multiple assignees" },
+  { flag: "--features", type: "string", required: false, description: "Feature flags as JSON" }
+]);
+registerSchema("space", "update", "Update a space", [
+  { flag: "<space-id>", type: "string", required: true, description: "Space ID" },
+  { flag: "--name", type: "string", required: false, description: "New space name" },
+  { flag: "--color", type: "string", required: false, description: "Space color" },
+  { flag: "--private", type: "boolean", required: false, description: "Make space private or public" }
+]);
+registerSchema("space", "delete", "Delete a space", [
+  { flag: "<space-id>", type: "string", required: true, description: "Space ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+var SPACE_COLUMNS = [
+  { key: "id", header: "ID", width: 14 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "private", header: "Private", width: 10 },
+  { key: "color", header: "Color", width: 10 },
+  { key: "multiple_assignees", header: "Multi-Assign", width: 14 }
+];
+function requireWorkspaceId2(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function registerSpaceCommands(program, getClient) {
+  const space = program.command("space").description("Manage spaces");
+  space.command("list").description("List spaces in a workspace").option("--archived", "Include archived spaces").action(async (opts) => {
+    const workspaceId = requireWorkspaceId2(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/space`, {
+      archived: opts.archived ? "true" : "false"
+    });
+    formatOutput(data.spaces, SPACE_COLUMNS, getOutputOptions(program));
+  });
+  space.command("get").description("Get space details").argument("<space-id>", "Space ID").action(async (spaceId) => {
+    const client = getClient();
+    const data = await client.get(`/space/${spaceId}`);
+    formatOutput(data, SPACE_COLUMNS, getOutputOptions(program));
+  });
+  space.command("create").description("Create a new space").requiredOption("--name <name>", "Space name").option("--multiple-assignees", "Enable multiple assignees").option("--features <json>", "Feature flags as JSON").action(async (opts) => {
+    const workspaceId = requireWorkspaceId2(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.multipleAssignees !== void 0) {
+      body["multiple_assignees"] = opts.multipleAssignees;
+    }
+    if (opts.features) {
+      body["features"] = JSON.parse(opts.features);
+    }
+    const data = await client.post(`/team/${workspaceId}/space`, body);
+    formatOutput(data, SPACE_COLUMNS, getOutputOptions(program));
+  });
+  space.command("update").description("Update a space").argument("<space-id>", "Space ID").option("--name <name>", "New space name").option("--color <hex>", "Space color").option("--private <bool>", "Make space private or public").action(async (spaceId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.color !== void 0) body["color"] = opts.color;
+    if (opts.private !== void 0) body["admin_can_manage"] = opts.private === "true";
+    const data = await client.put(`/space/${spaceId}`, body);
+    formatOutput(data, SPACE_COLUMNS, getOutputOptions(program));
+  });
+  space.command("delete").description("Delete a space").argument("<space-id>", "Space ID").option("--confirm", "Skip confirmation prompt").action(async (spaceId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete space ${spaceId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/space/${spaceId}`);
+    process.stdout.write(`Deleted space ${spaceId}
+`);
+  });
+}
+
+// src/commands/folder.ts
+registerSchema("folder", "list", "List folders in a space", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" },
+  { flag: "--archived", type: "boolean", required: false, description: "Include archived folders" }
+]);
+registerSchema("folder", "get", "Get folder details", [
+  { flag: "<folder-id>", type: "string", required: true, description: "Folder ID" }
+]);
+registerSchema("folder", "create", "Create a new folder", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" },
+  { flag: "--name", type: "string", required: true, description: "Folder name" }
+]);
+registerSchema("folder", "update", "Update a folder", [
+  { flag: "<folder-id>", type: "string", required: true, description: "Folder ID" },
+  { flag: "--name", type: "string", required: false, description: "New folder name" }
+]);
+registerSchema("folder", "delete", "Delete a folder", [
+  { flag: "<folder-id>", type: "string", required: true, description: "Folder ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+var FOLDER_COLUMNS = [
+  { key: "id", header: "ID", width: 14 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "task_count", header: "Tasks", width: 10 },
+  { key: "archived", header: "Archived", width: 10 }
+];
+function registerFolderCommands(program, getClient) {
+  const folder = program.command("folder").description("Manage folders");
+  folder.command("list").description("List folders in a space").requiredOption("--space-id <id>", "Space ID").option("--archived", "Include archived folders").action(async (opts) => {
+    const client = getClient();
+    const data = await client.get(`/space/${opts.spaceId}/folder`, {
+      archived: opts.archived ? "true" : "false"
+    });
+    formatOutput(data.folders, FOLDER_COLUMNS, getOutputOptions(program));
+  });
+  folder.command("get").description("Get folder details").argument("<folder-id>", "Folder ID").action(async (folderId) => {
+    const client = getClient();
+    const data = await client.get(`/folder/${folderId}`);
+    formatOutput(data, FOLDER_COLUMNS, getOutputOptions(program));
+  });
+  folder.command("create").description("Create a new folder").requiredOption("--space-id <id>", "Space ID").requiredOption("--name <name>", "Folder name").action(async (opts) => {
+    const client = getClient();
+    const data = await client.post(`/space/${opts.spaceId}/folder`, {
+      name: opts.name
+    });
+    formatOutput(data, FOLDER_COLUMNS, getOutputOptions(program));
+  });
+  folder.command("update").description("Update a folder").argument("<folder-id>", "Folder ID").option("--name <name>", "New folder name").action(async (folderId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    const data = await client.put(`/folder/${folderId}`, body);
+    formatOutput(data, FOLDER_COLUMNS, getOutputOptions(program));
+  });
+  folder.command("delete").description("Delete a folder").argument("<folder-id>", "Folder ID").option("--confirm", "Skip confirmation prompt").action(async (folderId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete folder ${folderId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/folder/${folderId}`);
+    process.stdout.write(`Deleted folder ${folderId}
+`);
+  });
+}
+
+// src/commands/list.ts
+registerSchema("list", "list", "List lists in a folder", [
+  { flag: "--folder-id", type: "string", required: true, description: "Folder ID" },
+  { flag: "--archived", type: "boolean", required: false, description: "Include archived lists" }
+]);
+registerSchema("list", "list-folderless", "List folderless lists in a space", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" },
+  { flag: "--archived", type: "boolean", required: false, description: "Include archived lists" }
+]);
+registerSchema("list", "get", "Get list details", [
+  { flag: "<list-id>", type: "string", required: true, description: "List ID" }
+]);
+registerSchema("list", "create", "Create a new list in a folder", [
+  { flag: "--folder-id", type: "string", required: true, description: "Folder ID" },
+  { flag: "--name", type: "string", required: true, description: "List name" },
+  { flag: "--content", type: "string", required: false, description: "List description" },
+  { flag: "--due-date", type: "string", required: false, description: "Due date (Unix ms)" },
+  { flag: "--priority", type: "integer", required: false, description: "Priority (1-4)" },
+  { flag: "--status", type: "string", required: false, description: "Default status" }
+]);
+registerSchema("list", "create-folderless", "Create a folderless list in a space", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" },
+  { flag: "--name", type: "string", required: true, description: "List name" },
+  { flag: "--content", type: "string", required: false, description: "List description" }
+]);
+registerSchema("list", "update", "Update a list", [
+  { flag: "<list-id>", type: "string", required: true, description: "List ID" },
+  { flag: "--name", type: "string", required: false, description: "New list name" },
+  { flag: "--content", type: "string", required: false, description: "New description" },
+  { flag: "--due-date", type: "string", required: false, description: "Due date (Unix ms)" },
+  { flag: "--unset-status", type: "boolean", required: false, description: "Remove default status" }
+]);
+registerSchema("list", "delete", "Delete a list", [
+  { flag: "<list-id>", type: "string", required: true, description: "List ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("list", "add-task", "Add a task to a list", [
+  { flag: "<list-id>", type: "string", required: true, description: "List ID" },
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" }
+]);
+registerSchema("list", "remove-task", "Remove a task from a list", [
+  { flag: "<list-id>", type: "string", required: true, description: "List ID" },
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" }
+]);
+var LIST_COLUMNS = [
+  { key: "id", header: "ID", width: 14 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "content", header: "Description", width: 25 },
+  { key: "task_count", header: "Tasks", width: 10 },
+  { key: "archived", header: "Archived", width: 10 }
+];
+function registerListCommands(program, getClient) {
+  const list = program.command("list").description("Manage lists");
+  list.command("list").description("List lists in a folder").requiredOption("--folder-id <id>", "Folder ID").option("--archived", "Include archived lists").action(async (opts) => {
+    const client = getClient();
+    const data = await client.get(`/folder/${opts.folderId}/list`, {
+      archived: opts.archived ? "true" : "false"
+    });
+    formatOutput(data.lists, LIST_COLUMNS, getOutputOptions(program));
+  });
+  list.command("list-folderless").description("List folderless lists in a space").requiredOption("--space-id <id>", "Space ID").option("--archived", "Include archived lists").action(async (opts) => {
+    const client = getClient();
+    const data = await client.get(`/space/${opts.spaceId}/list`, {
+      archived: opts.archived ? "true" : "false"
+    });
+    formatOutput(data.lists, LIST_COLUMNS, getOutputOptions(program));
+  });
+  list.command("get").description("Get list details").argument("<list-id>", "List ID").action(async (listId) => {
+    const client = getClient();
+    const data = await client.get(`/list/${listId}`);
+    formatOutput(data, LIST_COLUMNS, getOutputOptions(program));
+  });
+  list.command("create").description("Create a new list in a folder").requiredOption("--folder-id <id>", "Folder ID").requiredOption("--name <name>", "List name").option("--content <desc>", "List description").option("--due-date <ts>", "Due date (Unix ms)").option("--priority <n>", "Priority (1-4)", parseInt).option("--status <s>", "Default status").action(async (opts) => {
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.content !== void 0) body["content"] = opts.content;
+    if (opts.dueDate !== void 0) body["due_date"] = parseInt(opts.dueDate, 10);
+    if (opts.priority !== void 0) body["priority"] = opts.priority;
+    if (opts.status !== void 0) body["status"] = opts.status;
+    const data = await client.post(`/folder/${opts.folderId}/list`, body);
+    formatOutput(data, LIST_COLUMNS, getOutputOptions(program));
+  });
+  list.command("create-folderless").description("Create a folderless list in a space").requiredOption("--space-id <id>", "Space ID").requiredOption("--name <name>", "List name").option("--content <desc>", "List description").action(async (opts) => {
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.content !== void 0) body["content"] = opts.content;
+    const data = await client.post(`/space/${opts.spaceId}/list`, body);
+    formatOutput(data, LIST_COLUMNS, getOutputOptions(program));
+  });
+  list.command("update").description("Update a list").argument("<list-id>", "List ID").option("--name <name>", "New list name").option("--content <desc>", "New description").option("--due-date <ts>", "Due date (Unix ms)").option("--unset-status", "Remove default status").action(async (listId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.content !== void 0) body["content"] = opts.content;
+    if (opts.dueDate !== void 0) body["due_date"] = parseInt(opts.dueDate, 10);
+    if (opts.unsetStatus) body["unset_status"] = true;
+    const data = await client.put(`/list/${listId}`, body);
+    formatOutput(data, LIST_COLUMNS, getOutputOptions(program));
+  });
+  list.command("delete").description("Delete a list").argument("<list-id>", "List ID").option("--confirm", "Skip confirmation prompt").action(async (listId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete list ${listId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/list/${listId}`);
+    process.stdout.write(`Deleted list ${listId}
+`);
+  });
+  list.command("add-task").description("Add a task to a list").argument("<list-id>", "List ID").requiredOption("--task-id <id>", "Task ID").action(async (listId, opts) => {
+    const client = getClient();
+    await client.post(`/list/${listId}/task/${opts.taskId}`);
+    process.stdout.write(`Added task ${opts.taskId} to list ${listId}
+`);
+  });
+  list.command("remove-task").description("Remove a task from a list").argument("<list-id>", "List ID").requiredOption("--task-id <id>", "Task ID").action(async (listId, opts) => {
+    const client = getClient();
+    await client.delete(`/list/${listId}/task/${opts.taskId}`);
+    process.stdout.write(`Removed task ${opts.taskId} from list ${listId}
+`);
+  });
+}
+
+// src/commands/task.ts
+init_config();
+registerSchema("task", "list", "List tasks in a list", [
+  { flag: "--list-id", type: "string", required: true, description: "List ID" },
+  { flag: "--archived", type: "boolean", required: false, description: "Include archived tasks" },
+  { flag: "--include-closed", type: "boolean", required: false, description: "Include closed tasks" },
+  { flag: "--subtasks", type: "boolean", required: false, description: "Include subtasks" },
+  { flag: "--page", type: "integer", required: false, description: "Page number (0-indexed)" },
+  { flag: "--status", type: "string[]", required: false, description: "Filter by status (repeatable)" },
+  { flag: "--assignee", type: "string[]", required: false, description: "Filter by assignee ID (repeatable)" },
+  { flag: "--tag", type: "string[]", required: false, description: "Filter by tag name (repeatable)" },
+  { flag: "--order-by", type: "string", required: false, description: "Sort field (id|created|updated|due_date)" },
+  { flag: "--reverse", type: "boolean", required: false, description: "Reverse sort order" }
+]);
+registerSchema("task", "search", "Search tasks across a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--query", type: "string", required: false, description: "Full-text search query" },
+  { flag: "--include-closed", type: "boolean", required: false, description: "Include closed tasks" },
+  { flag: "--status", type: "string[]", required: false, description: "Filter by status (repeatable)" },
+  { flag: "--assignee", type: "string[]", required: false, description: "Filter by assignee ID (repeatable)" },
+  { flag: "--tag", type: "string[]", required: false, description: "Filter by tag name (repeatable)" },
+  { flag: "--page", type: "integer", required: false, description: "Page number (0-indexed)" }
+]);
+registerSchema("task", "get", "Get task details", [
+  { flag: "<task-id>", type: "string", required: true, description: "Task ID" },
+  { flag: "--include-subtasks", type: "boolean", required: false, description: "Include subtasks" },
+  { flag: "--include-markdown-description", type: "boolean", required: false, description: "Return description as Markdown" }
+]);
+registerSchema("task", "create", "Create a new task", [
+  { flag: "--list-id", type: "string", required: true, description: "List ID" },
+  { flag: "--name", type: "string", required: true, description: "Task name" },
+  { flag: "--description", type: "string", required: false, description: "Plain text description" },
+  { flag: "--markdown-description", type: "string", required: false, description: "Markdown description" },
+  { flag: "--status", type: "string", required: false, description: "Initial status" },
+  { flag: "--priority", type: "integer", required: false, description: "Priority (1=urgent, 2=high, 3=normal, 4=low)" },
+  { flag: "--due-date", type: "string", required: false, description: "Due date (Unix ms)" },
+  { flag: "--start-date", type: "string", required: false, description: "Start date (Unix ms)" },
+  { flag: "--assignee", type: "string[]", required: false, description: "Assignee user ID (repeatable)" },
+  { flag: "--tag", type: "string[]", required: false, description: "Tag name (repeatable)" },
+  { flag: "--time-estimate", type: "integer", required: false, description: "Time estimate in ms" },
+  { flag: "--parent", type: "string", required: false, description: "Parent task ID (creates subtask)" }
+]);
+registerSchema("task", "update", "Update a task", [
+  { flag: "<task-id>", type: "string", required: true, description: "Task ID" },
+  { flag: "--name", type: "string", required: false, description: "New task name" },
+  { flag: "--description", type: "string", required: false, description: "New description" },
+  { flag: "--status", type: "string", required: false, description: "New status" },
+  { flag: "--priority", type: "integer", required: false, description: "New priority (1-4)" },
+  { flag: "--due-date", type: "string", required: false, description: "New due date (Unix ms)" },
+  { flag: "--assignee-add", type: "string[]", required: false, description: "Add assignee (repeatable)" },
+  { flag: "--assignee-remove", type: "string[]", required: false, description: "Remove assignee (repeatable)" }
+]);
+registerSchema("task", "delete", "Delete a task", [
+  { flag: "<task-id>", type: "string", required: true, description: "Task ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("task", "time-in-status", "Get time spent in each status for a task", [
+  { flag: "<task-id>", type: "string", required: true, description: "Task ID" }
+]);
+var TASK_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "status", header: "Status", width: 15 },
+  { key: "priority", header: "Priority", width: 10 },
+  { key: "assignees", header: "Assignees", width: 20 },
+  { key: "due_date", header: "Due Date", width: 15 }
+];
+var TIME_IN_STATUS_COLUMNS = [
+  { key: "status", header: "Status", width: 20 },
+  { key: "color", header: "Color", width: 10 },
+  { key: "total_time", header: "Total Time", width: 20 }
+];
+function requireWorkspaceId3(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+function buildTaskListParams(opts) {
+  const params = {};
+  if (opts.archived) params["archived"] = "true";
+  if (opts.includeClosed) params["include_closed"] = "true";
+  if (opts.subtasks) params["subtasks"] = "true";
+  if (opts.page !== void 0) params["page"] = String(opts.page);
+  if (opts.orderBy) params["order_by"] = opts.orderBy;
+  if (opts.reverse) params["reverse"] = "true";
+  if (opts.dueDateGt) params["due_date_gt"] = opts.dueDateGt;
+  if (opts.dueDateLt) params["due_date_lt"] = opts.dueDateLt;
+  if (opts.dateCreatedGt) params["date_created_gt"] = opts.dateCreatedGt;
+  if (opts.dateCreatedLt) params["date_created_lt"] = opts.dateCreatedLt;
+  if (opts.dateUpdatedGt) params["date_updated_gt"] = opts.dateUpdatedGt;
+  if (opts.dateUpdatedLt) params["date_updated_lt"] = opts.dateUpdatedLt;
+  const statuses = opts.status;
+  if (statuses?.length) params["statuses[]"] = statuses;
+  const assignees = opts.assignee;
+  if (assignees?.length) params["assignees[]"] = assignees;
+  const tags = opts.tag;
+  if (tags?.length) params["tags[]"] = tags;
+  const customFields = opts.customField;
+  if (customFields?.length) {
+    for (const cf of customFields) params["custom_fields"] = JSON.stringify(customFields.map((f) => JSON.parse(f)));
+  }
+  return params;
+}
+function registerTaskCommands(program, getClient) {
+  const task = program.command("task").description("Manage tasks");
+  task.command("list").description("List tasks in a list").requiredOption("--list-id <id>", "List ID").option("--archived", "Include archived tasks").option("--include-closed", "Include tasks in closed status").option("--subtasks", "Include subtasks in results").option("--page <n>", "Page number (0-indexed)", parseInt).option("--status <s>", "Filter by status (repeatable)", collect, []).option("--assignee <id>", "Filter by assignee ID (repeatable)", collect, []).option("--tag <name>", "Filter by tag name (repeatable)", collect, []).option("--due-date-gt <ts>", "Tasks due after timestamp").option("--due-date-lt <ts>", "Tasks due before timestamp").option("--date-created-gt <ts>", "Tasks created after timestamp").option("--date-created-lt <ts>", "Tasks created before timestamp").option("--date-updated-gt <ts>", "Tasks updated after timestamp").option("--date-updated-lt <ts>", "Tasks updated before timestamp").option("--custom-field <json>", "Custom field filter as JSON (repeatable)", collect, []).option("--order-by <field>", "Sort by field (id|created|updated|due_date)").option("--reverse", "Reverse sort order").action(async (opts) => {
+    const client = getClient();
+    const params = buildTaskListParams(opts);
+    const data = await client.get(`/list/${opts.listId}/task`, params);
+    formatOutput(data.tasks, TASK_COLUMNS, getOutputOptions(program));
+  });
+  task.command("search").description("Search tasks across a workspace").option("--query <text>", "Full-text search query").option("--include-closed", "Include tasks in closed status").option("--subtasks", "Include subtasks").option("--page <n>", "Page number (0-indexed)", parseInt).option("--status <s>", "Filter by status (repeatable)", collect, []).option("--assignee <id>", "Filter by assignee ID (repeatable)", collect, []).option("--tag <name>", "Filter by tag name (repeatable)", collect, []).option("--priority <n>", "Filter by priority (repeatable)", collect, []).option("--list-id <id>", "Scope to list IDs (repeatable)", collect, []).option("--folder-id <id>", "Scope to folder IDs (repeatable)", collect, []).option("--space-id <id>", "Scope to space IDs (repeatable)", collect, []).option("--project-id <id>", "Scope to project IDs (repeatable)", collect, []).option("--due-date-gt <ts>", "Tasks due after timestamp").option("--due-date-lt <ts>", "Tasks due before timestamp").option("--date-created-gt <ts>", "Tasks created after timestamp").option("--date-created-lt <ts>", "Tasks created before timestamp").option("--custom-field <json>", "Custom field filter as JSON (repeatable)", collect, []).option("--order-by <field>", "Sort by field (id|created|updated|due_date)").option("--reverse", "Reverse sort order").action(async (opts) => {
+    const workspaceId = requireWorkspaceId3(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const params = {};
+    if (opts.query) params["query"] = opts.query;
+    if (opts.includeClosed) params["include_closed"] = "true";
+    if (opts.subtasks) params["subtasks"] = "true";
+    if (opts.page !== void 0) params["page"] = String(opts.page);
+    if (opts.orderBy) params["order_by"] = opts.orderBy;
+    if (opts.reverse) params["reverse"] = "true";
+    if (opts.dueDateGt) params["due_date_gt"] = opts.dueDateGt;
+    if (opts.dueDateLt) params["due_date_lt"] = opts.dueDateLt;
+    if (opts.dateCreatedGt) params["date_created_gt"] = opts.dateCreatedGt;
+    if (opts.dateCreatedLt) params["date_created_lt"] = opts.dateCreatedLt;
+    const statuses = opts.status;
+    if (statuses.length) params["statuses[]"] = statuses;
+    const assignees = opts.assignee;
+    if (assignees.length) params["assignees[]"] = assignees;
+    const tags = opts.tag;
+    if (tags.length) params["tags[]"] = tags;
+    const priorities = opts.priority;
+    if (priorities.length) params["priorities[]"] = priorities;
+    const listIds = opts.listId;
+    if (listIds.length) params["list_ids[]"] = listIds;
+    const folderIds = opts.folderId;
+    if (folderIds.length) params["folder_ids[]"] = folderIds;
+    const spaceIds = opts.spaceId;
+    if (spaceIds.length) params["space_ids[]"] = spaceIds;
+    const projectIds = opts.projectId;
+    if (projectIds.length) params["project_ids[]"] = projectIds;
+    const customFields = opts.customField;
+    if (customFields.length) params["custom_fields"] = JSON.stringify(customFields.map((f) => JSON.parse(f)));
+    const data = await client.get(`/team/${workspaceId}/task`, params);
+    formatOutput(data.tasks, TASK_COLUMNS, getOutputOptions(program));
+  });
+  task.command("get").description("Get task details").argument("<task-id>", "Task ID").option("--include-subtasks", "Include subtasks").option("--include-markdown-description", "Return description as Markdown").action(async (taskId, opts) => {
+    const client = getClient();
+    const params = {};
+    if (opts.includeSubtasks) params["include_subtasks"] = "true";
+    if (opts.includeMarkdownDescription) params["include_markdown_description"] = "true";
+    const data = await client.get(`/task/${taskId}`, params);
+    formatOutput(data, TASK_COLUMNS, getOutputOptions(program));
+  });
+  task.command("create").description("Create a new task").requiredOption("--list-id <id>", "List ID").requiredOption("--name <name>", "Task name").option("--description <desc>", "Plain text description").option("--markdown-description <md>", "Markdown description (overrides --description)").option("--status <s>", "Initial status").option("--priority <n>", "Priority (1=urgent, 2=high, 3=normal, 4=low)", parseInt).option("--due-date <date>", "Due date (Unix ms)").option("--start-date <date>", "Start date (Unix ms)").option("--assignee <id>", "Assignee user ID (repeatable)", collect, []).option("--tag <name>", "Tag name (repeatable)", collect, []).option("--time-estimate <ms>", "Time estimate in milliseconds", parseInt).option("--notify-all", "Notify all assignees and watchers").option("--parent <task-id>", "Parent task ID (creates subtask)").option("--links-to <task-id>", "Link to another task").option("--custom-field <id=value>", "Set custom field (repeatable)", collect, []).option("--check-required-custom-fields", "Reject if required custom fields are missing").action(async (opts) => {
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.markdownDescription !== void 0) body["markdown_description"] = opts.markdownDescription;
+    else if (opts.description !== void 0) body["description"] = opts.description;
+    if (opts.status !== void 0) body["status"] = opts.status;
+    if (opts.priority !== void 0) body["priority"] = opts.priority;
+    if (opts.dueDate !== void 0) body["due_date"] = parseInt(opts.dueDate, 10);
+    if (opts.startDate !== void 0) body["start_date"] = parseInt(opts.startDate, 10);
+    const assignees = opts.assignee;
+    if (assignees.length) body["assignees"] = assignees.map((a) => parseInt(a, 10));
+    const tags = opts.tag;
+    if (tags.length) body["tags"] = tags;
+    if (opts.timeEstimate !== void 0) body["time_estimate"] = opts.timeEstimate;
+    if (opts.notifyAll) body["notify_all"] = true;
+    if (opts.parent !== void 0) body["parent"] = opts.parent;
+    if (opts.linksTo !== void 0) body["links_to"] = opts.linksTo;
+    const customFields = opts.customField;
+    if (customFields.length) {
+      body["custom_fields"] = customFields.map((cf) => {
+        const eqIdx = cf.indexOf("=");
+        if (eqIdx === -1) throw new Error(`Invalid custom field format: ${cf}. Expected: <id>=<value>`);
+        const id = cf.slice(0, eqIdx);
+        let value = cf.slice(eqIdx + 1);
+        try {
+          value = JSON.parse(value);
+        } catch {
+        }
+        return { id, value };
+      });
+    }
+    if (opts.checkRequiredCustomFields) body["check_required_custom_fields"] = true;
+    const data = await client.post(`/list/${opts.listId}/task`, body);
+    formatOutput(data, TASK_COLUMNS, getOutputOptions(program));
+  });
+  task.command("update").description("Update a task").argument("<task-id>", "Task ID").option("--name <name>", "New task name").option("--description <desc>", "New description").option("--status <s>", "New status").option("--priority <n>", "New priority (1-4)", parseInt).option("--due-date <date>", "New due date (Unix ms)").option("--start-date <date>", "New start date (Unix ms)").option("--time-estimate <ms>", "New time estimate in milliseconds", parseInt).option("--assignee-add <id>", "Add assignee (repeatable)", collect, []).option("--assignee-remove <id>", "Remove assignee (repeatable)", collect, []).option("--archived <bool>", "Archive or unarchive").action(async (taskId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.description !== void 0) body["description"] = opts.description;
+    if (opts.status !== void 0) body["status"] = opts.status;
+    if (opts.priority !== void 0) body["priority"] = opts.priority;
+    if (opts.dueDate !== void 0) body["due_date"] = parseInt(opts.dueDate, 10);
+    if (opts.startDate !== void 0) body["start_date"] = parseInt(opts.startDate, 10);
+    if (opts.timeEstimate !== void 0) body["time_estimate"] = opts.timeEstimate;
+    const addIds = opts.assigneeAdd;
+    const remIds = opts.assigneeRemove;
+    if (addIds.length || remIds.length) {
+      body["assignees"] = {
+        add: addIds.map((a) => parseInt(a, 10)),
+        rem: remIds.map((a) => parseInt(a, 10))
+      };
+    }
+    if (opts.archived !== void 0) body["archived"] = opts.archived === "true";
+    const data = await client.put(`/task/${taskId}`, body);
+    formatOutput(data, TASK_COLUMNS, getOutputOptions(program));
+  });
+  task.command("delete").description("Delete a task").argument("<task-id>", "Task ID").option("--confirm", "Skip confirmation prompt").action(async (taskId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete task ${taskId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/task/${taskId}`);
+    process.stdout.write(`Deleted task ${taskId}
+`);
+  });
+  task.command("time-in-status").description("Get time spent in each status").argument("<task-id>", "Task ID").action(async (taskId) => {
+    const client = getClient();
+    const data = await client.get(`/task/${taskId}/time_in_status`);
+    const entries = data.status_history ?? [];
+    if (data.current_status) entries.push(data.current_status);
+    formatOutput(entries, TIME_IN_STATUS_COLUMNS, getOutputOptions(program));
+  });
+  task.command("bulk-time-in-status").description("Get time-in-status for multiple tasks").requiredOption("--task-id <id>", "Task ID (repeatable)", collect, []).action(async (opts) => {
+    const client = getClient();
+    const taskIds = opts.taskId;
+    const results = [];
+    for (const id of taskIds) {
+      const data = await client.get(`/task/${id}/time_in_status`);
+      const entries = data.status_history ?? [];
+      if (data.current_status) entries.push(data.current_status);
+      results.push({ task_id: id, statuses: entries });
+    }
+    formatOutput(results, [
+      { key: "task_id", header: "Task ID", width: 14 },
+      { key: "statuses", header: "Statuses", width: 50 }
+    ], getOutputOptions(program));
+  });
+}
+
+// src/commands/checklist.ts
+registerSchema("checklist", "create", "Create a checklist on a task", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--name", type: "string", required: true, description: "Checklist name" }
+]);
+registerSchema("checklist", "update", "Update a checklist", [
+  { flag: "<checklist-id>", type: "string", required: true, description: "Checklist ID" },
+  { flag: "--name", type: "string", required: false, description: "New checklist name" },
+  { flag: "--position", type: "integer", required: false, description: "Position (0-indexed)" }
+]);
+registerSchema("checklist", "delete", "Delete a checklist", [
+  { flag: "<checklist-id>", type: "string", required: true, description: "Checklist ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("checklist", "add-item", "Add an item to a checklist", [
+  { flag: "<checklist-id>", type: "string", required: true, description: "Checklist ID" },
+  { flag: "--name", type: "string", required: true, description: "Item name" },
+  { flag: "--assignee", type: "string", required: false, description: "Assignee user ID" },
+  { flag: "--resolved", type: "boolean", required: false, description: "Mark as resolved" }
+]);
+registerSchema("checklist", "update-item", "Update a checklist item", [
+  { flag: "<checklist-id>", type: "string", required: true, description: "Checklist ID" },
+  { flag: "--item-id", type: "string", required: true, description: "Item ID" },
+  { flag: "--name", type: "string", required: false, description: "New item name" },
+  { flag: "--resolved", type: "boolean", required: false, description: "Resolved status" },
+  { flag: "--assignee", type: "string", required: false, description: "Assignee user ID" }
+]);
+registerSchema("checklist", "delete-item", "Delete a checklist item", [
+  { flag: "<checklist-id>", type: "string", required: true, description: "Checklist ID" },
+  { flag: "--item-id", type: "string", required: true, description: "Item ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+var CHECKLIST_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "resolved", header: "Resolved", width: 10 },
+  { key: "unresolved", header: "Unresolved", width: 10 }
+];
+function registerChecklistCommands(program, getClient) {
+  const checklist = program.command("checklist").description("Manage checklists");
+  checklist.command("create").description("Create a checklist on a task").requiredOption("--task-id <id>", "Task ID").requiredOption("--name <name>", "Checklist name").action(async (opts) => {
+    const client = getClient();
+    const data = await client.post(`/task/${opts.taskId}/checklist`, { name: opts.name });
+    formatOutput(data.checklist, CHECKLIST_COLUMNS, getOutputOptions(program));
+  });
+  checklist.command("update").description("Update a checklist").argument("<checklist-id>", "Checklist ID").option("--name <name>", "New checklist name").option("--position <n>", "Position (0-indexed)", parseInt).action(async (checklistId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.position !== void 0) body["position"] = opts.position;
+    const data = await client.put(`/checklist/${checklistId}`, body);
+    formatOutput(data.checklist, CHECKLIST_COLUMNS, getOutputOptions(program));
+  });
+  checklist.command("delete").description("Delete a checklist").argument("<checklist-id>", "Checklist ID").option("--confirm", "Skip confirmation prompt").action(async (checklistId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete checklist ${checklistId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/checklist/${checklistId}`);
+    process.stdout.write(`Deleted checklist ${checklistId}
+`);
+  });
+  checklist.command("add-item").description("Add an item to a checklist").argument("<checklist-id>", "Checklist ID").requiredOption("--name <name>", "Item name").option("--assignee <id>", "Assignee user ID").option("--resolved <bool>", "Mark as resolved").option("--parent <item-id>", "Parent item ID").action(async (checklistId, opts) => {
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.assignee !== void 0) body["assignee"] = parseInt(opts.assignee, 10);
+    if (opts.resolved !== void 0) body["resolved"] = opts.resolved === "true";
+    if (opts.parent !== void 0) body["parent"] = opts.parent;
+    const data = await client.post(`/checklist/${checklistId}/checklist_item`, body);
+    formatOutput(data.checklist, CHECKLIST_COLUMNS, getOutputOptions(program));
+  });
+  checklist.command("update-item").description("Update a checklist item").argument("<checklist-id>", "Checklist ID").requiredOption("--item-id <id>", "Item ID").option("--name <name>", "New item name").option("--resolved <bool>", "Mark as resolved/unresolved").option("--assignee <id>", "Assignee user ID").option("--parent <item-id>", "Parent item ID").action(async (checklistId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.resolved !== void 0) body["resolved"] = opts.resolved === "true";
+    if (opts.assignee !== void 0) body["assignee"] = parseInt(opts.assignee, 10);
+    if (opts.parent !== void 0) body["parent"] = opts.parent;
+    const data = await client.put(`/checklist/${checklistId}/checklist_item/${opts.itemId}`, body);
+    formatOutput(data.checklist, CHECKLIST_COLUMNS, getOutputOptions(program));
+  });
+  checklist.command("delete-item").description("Delete a checklist item").argument("<checklist-id>", "Checklist ID").requiredOption("--item-id <id>", "Item ID").option("--confirm", "Skip confirmation prompt").action(async (checklistId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete checklist item ${opts.itemId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/checklist/${checklistId}/checklist_item/${opts.itemId}`);
+    process.stdout.write(`Deleted checklist item ${opts.itemId}
+`);
+  });
+}
+
+// src/commands/custom-field.ts
+registerSchema("field", "list", "List custom fields for a list, folder, space, or workspace", [
+  { flag: "--list-id", type: "string", required: false, description: "List ID" },
+  { flag: "--folder-id", type: "string", required: false, description: "Folder ID" },
+  { flag: "--space-id", type: "string", required: false, description: "Space ID" },
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID" }
+]);
+registerSchema("field", "set", "Set a custom field value on a task", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--field-id", type: "string", required: true, description: "Field ID" },
+  { flag: "--value", type: "string", required: true, description: "Field value" }
+]);
+registerSchema("field", "remove", "Remove a custom field value from a task", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--field-id", type: "string", required: true, description: "Field ID" }
+]);
+var FIELD_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "name", header: "Name", width: 25 },
+  { key: "type", header: "Type", width: 15 },
+  { key: "required", header: "Required", width: 10 },
+  { key: "date_created", header: "Created", width: 15 }
+];
+function registerFieldCommands(program, getClient) {
+  const field = program.command("field").description("Manage custom fields");
+  field.command("list").description("List custom fields (provide one ID flag)").option("--list-id <id>", "List ID").option("--folder-id <id>", "Folder ID").option("--space-id <id>", "Space ID").action(async (opts) => {
+    const client = getClient();
+    const globalWorkspaceId = program.opts()["workspaceId"];
+    let endpoint;
+    if (opts.listId) {
+      endpoint = `/list/${opts.listId}/field`;
+    } else if (opts.folderId) {
+      endpoint = `/folder/${opts.folderId}/field`;
+    } else if (opts.spaceId) {
+      endpoint = `/space/${opts.spaceId}/field`;
+    } else if (globalWorkspaceId) {
+      endpoint = `/team/${globalWorkspaceId}/field`;
+    } else {
+      process.stderr.write("Error: Provide one of --list-id, --folder-id, --space-id, or --workspace-id.\n");
+      process.exit(2);
+      return;
+    }
+    const data = await client.get(endpoint);
+    formatOutput(data.fields, FIELD_COLUMNS, getOutputOptions(program));
+  });
+  field.command("set").description("Set a custom field value on a task").requiredOption("--task-id <id>", "Task ID").requiredOption("--field-id <fid>", "Field ID").requiredOption("--value <value>", "Field value").action(async (opts) => {
+    const client = getClient();
+    let parsedValue = opts.value;
+    try {
+      parsedValue = JSON.parse(opts.value);
+    } catch {
+    }
+    const data = await client.post(`/task/${opts.taskId}/field/${opts.fieldId}`, { value: parsedValue });
+    formatOutput(data, FIELD_COLUMNS, getOutputOptions(program));
+  });
+  field.command("remove").description("Remove a custom field value from a task").requiredOption("--task-id <id>", "Task ID").requiredOption("--field-id <fid>", "Field ID").action(async (opts) => {
+    const client = getClient();
+    await client.delete(`/task/${opts.taskId}/field/${opts.fieldId}`);
+    process.stdout.write(`Removed field ${opts.fieldId} from task ${opts.taskId}
+`);
+  });
+}
+
+// src/commands/tag.ts
+registerSchema("tag", "list", "List tags in a space", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" }
+]);
+registerSchema("tag", "create", "Create a tag in a space", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" },
+  { flag: "--name", type: "string", required: true, description: "Tag name" },
+  { flag: "--fg-color", type: "string", required: false, description: "Text color hex" },
+  { flag: "--bg-color", type: "string", required: false, description: "Background color hex" }
+]);
+registerSchema("tag", "update", "Update a tag in a space", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" },
+  { flag: "--name", type: "string", required: true, description: "Current tag name" },
+  { flag: "--new-name", type: "string", required: false, description: "New tag name" },
+  { flag: "--fg-color", type: "string", required: false, description: "New text color" },
+  { flag: "--bg-color", type: "string", required: false, description: "New background color" }
+]);
+registerSchema("tag", "delete", "Delete a tag from a space", [
+  { flag: "--space-id", type: "string", required: true, description: "Space ID" },
+  { flag: "--name", type: "string", required: true, description: "Tag name" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("tag", "add", "Add a tag to a task", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--name", type: "string", required: true, description: "Tag name" }
+]);
+registerSchema("tag", "remove", "Remove a tag from a task", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--name", type: "string", required: true, description: "Tag name" }
+]);
+var TAG_COLUMNS = [
+  { key: "name", header: "Name", width: 25 },
+  { key: "tag_fg", header: "FG Color", width: 12 },
+  { key: "tag_bg", header: "BG Color", width: 12 }
+];
+function registerTagCommands(program, getClient) {
+  const tag = program.command("tag").description("Manage tags");
+  tag.command("list").description("List tags in a space").requiredOption("--space-id <id>", "Space ID").action(async (opts) => {
+    const client = getClient();
+    const data = await client.get(`/space/${opts.spaceId}/tag`);
+    formatOutput(data.tags, TAG_COLUMNS, getOutputOptions(program));
+  });
+  tag.command("create").description("Create a tag in a space").requiredOption("--space-id <id>", "Space ID").requiredOption("--name <name>", "Tag name").option("--fg-color <hex>", "Text color (e.g. #FFFFFF)").option("--bg-color <hex>", "Background color (e.g. #8B5CF6)").action(async (opts) => {
+    const client = getClient();
+    const tagObj = { name: opts.name };
+    if (opts.fgColor !== void 0) tagObj["tag_fg"] = opts.fgColor;
+    if (opts.bgColor !== void 0) tagObj["tag_bg"] = opts.bgColor;
+    await client.post(`/space/${opts.spaceId}/tag`, { tag: tagObj });
+    process.stdout.write(`Created tag "${opts.name}"
+`);
+  });
+  tag.command("update").description("Update a tag in a space").requiredOption("--space-id <id>", "Space ID").requiredOption("--name <name>", "Current tag name").option("--new-name <name>", "New tag name").option("--fg-color <hex>", "New text color").option("--bg-color <hex>", "New background color").action(async (opts) => {
+    const client = getClient();
+    const tagObj = {};
+    if (opts.newName !== void 0) tagObj["name"] = opts.newName;
+    if (opts.fgColor !== void 0) tagObj["tag_fg"] = opts.fgColor;
+    if (opts.bgColor !== void 0) tagObj["tag_bg"] = opts.bgColor;
+    await client.put(`/space/${opts.spaceId}/tag/${encodeURIComponent(opts.name)}`, { tag: tagObj });
+    process.stdout.write(`Updated tag "${opts.name}"
+`);
+  });
+  tag.command("delete").description("Delete a tag from a space").requiredOption("--space-id <id>", "Space ID").requiredOption("--name <name>", "Tag name").option("--confirm", "Skip confirmation prompt").action(async (opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete tag "${opts.name}"?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/space/${opts.spaceId}/tag/${encodeURIComponent(opts.name)}`);
+    process.stdout.write(`Deleted tag "${opts.name}"
+`);
+  });
+  tag.command("add").description("Add a tag to a task").requiredOption("--task-id <id>", "Task ID").requiredOption("--name <name>", "Tag name").action(async (opts) => {
+    const client = getClient();
+    await client.post(`/task/${opts.taskId}/tag/${encodeURIComponent(opts.name)}`);
+    process.stdout.write(`Added tag "${opts.name}" to task ${opts.taskId}
+`);
+  });
+  tag.command("remove").description("Remove a tag from a task").requiredOption("--task-id <id>", "Task ID").requiredOption("--name <name>", "Tag name").action(async (opts) => {
+    const client = getClient();
+    await client.delete(`/task/${opts.taskId}/tag/${encodeURIComponent(opts.name)}`);
+    process.stdout.write(`Removed tag "${opts.name}" from task ${opts.taskId}
+`);
+  });
+}
+
+// src/commands/dependency.ts
+registerSchema("dependency", "add", "Add a dependency between tasks", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--depends-on", type: "string", required: false, description: "This task depends on the given task" },
+  { flag: "--dependency-of", type: "string", required: false, description: "This task is a dependency of the given task" }
+]);
+registerSchema("dependency", "remove", "Remove a dependency between tasks", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--depends-on", type: "string", required: false, description: "Remove depends-on relationship" },
+  { flag: "--dependency-of", type: "string", required: false, description: "Remove dependency-of relationship" }
+]);
+var DEPENDENCY_COLUMNS = [
+  { key: "task_id", header: "Task ID", width: 14 },
+  { key: "depends_on", header: "Depends On", width: 14 },
+  { key: "dependency_of", header: "Dependency Of", width: 14 }
+];
+function registerDependencyCommands(program, getClient) {
+  const dependency = program.command("dependency").description("Manage task dependencies");
+  dependency.command("add").description("Add a dependency between tasks").requiredOption("--task-id <id>", "Task ID").option("--depends-on <id>", "This task depends on the given task").option("--dependency-of <id>", "This task is a dependency of the given task").action(async (opts) => {
+    if (!opts.dependsOn && !opts.dependencyOf) {
+      process.stderr.write("Error: Provide --depends-on or --dependency-of.\n");
+      process.exit(2);
+      return;
+    }
+    const client = getClient();
+    const body = {};
+    if (opts.dependsOn) body["depends_on"] = opts.dependsOn;
+    if (opts.dependencyOf) body["dependency_of"] = opts.dependencyOf;
+    const data = await client.post(`/task/${opts.taskId}/dependency`, body);
+    formatOutput(data, DEPENDENCY_COLUMNS, getOutputOptions(program));
+  });
+  dependency.command("remove").description("Remove a dependency between tasks").requiredOption("--task-id <id>", "Task ID").option("--depends-on <id>", "Remove depends-on relationship").option("--dependency-of <id>", "Remove dependency-of relationship").action(async (opts) => {
+    if (!opts.dependsOn && !opts.dependencyOf) {
+      process.stderr.write("Error: Provide --depends-on or --dependency-of.\n");
+      process.exit(2);
+      return;
+    }
+    const client = getClient();
+    const params = {};
+    if (opts.dependsOn) params["depends_on"] = opts.dependsOn;
+    if (opts.dependencyOf) params["dependency_of"] = opts.dependencyOf;
+    await client.delete(`/task/${opts.taskId}/dependency?${new URLSearchParams(params).toString()}`);
+    process.stdout.write(`Removed dependency from task ${opts.taskId}
+`);
+  });
+}
+
+// src/commands/relation.ts
+registerSchema("relation", "add", "Add a relation between tasks", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--links-to", type: "string", required: true, description: "Task ID to link to" }
+]);
+registerSchema("relation", "remove", "Remove a relation between tasks", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--links-to", type: "string", required: true, description: "Task ID to unlink from" }
+]);
+var RELATION_COLUMNS = [
+  { key: "task_id", header: "Task ID", width: 14 },
+  { key: "links_to", header: "Links To", width: 14 }
+];
+function registerRelationCommands(program, getClient) {
+  const relation = program.command("relation").description("Manage task relations");
+  relation.command("add").description("Add a relation between tasks").requiredOption("--task-id <id>", "Task ID").requiredOption("--links-to <id>", "Task ID to link to").action(async (opts) => {
+    const client = getClient();
+    const data = await client.post(`/task/${opts.taskId}/link/${opts.linksTo}`);
+    formatOutput(data, RELATION_COLUMNS, getOutputOptions(program));
+  });
+  relation.command("remove").description("Remove a relation between tasks").requiredOption("--task-id <id>", "Task ID").requiredOption("--links-to <id>", "Task ID to unlink from").action(async (opts) => {
+    const client = getClient();
+    await client.delete(`/task/${opts.taskId}/link/${opts.linksTo}`);
+    process.stdout.write(`Removed relation between task ${opts.taskId} and ${opts.linksTo}
+`);
+  });
+}
+
+// src/commands/attachment.ts
+registerSchema("attachment", "upload", "Upload a file to a task", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--file", type: "string", required: true, description: "Local file path" },
+  { flag: "--filename", type: "string", required: false, description: "Override display filename" }
+]);
+var ATTACHMENT_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "title", header: "Title", width: 30 },
+  { key: "url", header: "URL", width: 40 },
+  { key: "type", header: "Type", width: 15 },
+  { key: "size", header: "Size", width: 10 }
+];
+function registerAttachmentCommands(program, getClient) {
+  const attachment = program.command("attachment").description("Manage attachments");
+  attachment.command("upload").description("Upload a file to a task").requiredOption("--task-id <id>", "Task ID").requiredOption("--file <path>", "Local file path").option("--filename <name>", "Override display filename").action(async (opts) => {
+    const client = getClient();
+    const data = await client.upload(`/task/${opts.taskId}/attachment`, opts.file, opts.filename);
+    formatOutput(data, ATTACHMENT_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/comment.ts
+registerSchema("comment", "list", "List comments on a task, list, or view", [
+  { flag: "--task-id", type: "string", required: false, description: "Task ID (provide one parent)" },
+  { flag: "--list-id", type: "string", required: false, description: "List ID (provide one parent)" },
+  { flag: "--view-id", type: "string", required: false, description: "View ID (provide one parent)" },
+  { flag: "--start", type: "string", required: false, description: "Pagination start timestamp" },
+  { flag: "--start-id", type: "string", required: false, description: "Pagination start comment ID" }
+]);
+registerSchema("comment", "create", "Create a comment on a task, list, or view", [
+  { flag: "--task-id", type: "string", required: false, description: "Task ID (provide one parent)" },
+  { flag: "--list-id", type: "string", required: false, description: "List ID (provide one parent)" },
+  { flag: "--view-id", type: "string", required: false, description: "View ID (provide one parent)" },
+  { flag: "--text", type: "string", required: true, description: "Comment text" },
+  { flag: "--assignee", type: "string", required: false, description: "Assignee user ID" },
+  { flag: "--notify-all", type: "boolean", required: false, description: "Notify all watchers" }
+]);
+registerSchema("comment", "update", "Update a comment", [
+  { flag: "<comment-id>", type: "string", required: true, description: "Comment ID" },
+  { flag: "--text", type: "string", required: true, description: "New comment text" },
+  { flag: "--assignee", type: "string", required: false, description: "Assignee user ID" },
+  { flag: "--resolved", type: "boolean", required: false, description: "Mark as resolved" }
+]);
+registerSchema("comment", "delete", "Delete a comment", [
+  { flag: "<comment-id>", type: "string", required: true, description: "Comment ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("comment", "list-threaded", "List threaded replies to a comment", [
+  { flag: "<comment-id>", type: "string", required: true, description: "Comment ID" }
+]);
+registerSchema("comment", "reply", "Reply to a comment (threaded)", [
+  { flag: "<comment-id>", type: "string", required: true, description: "Comment ID" },
+  { flag: "--text", type: "string", required: true, description: "Reply text" },
+  { flag: "--assignee", type: "string", required: false, description: "Assignee user ID" },
+  { flag: "--notify-all", type: "boolean", required: false, description: "Notify all watchers" }
+]);
+var COMMENT_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "comment_text", header: "Text", width: 40 },
+  { key: "user_name", header: "User", width: 15 },
+  { key: "assignee_name", header: "Assignee", width: 15 },
+  { key: "resolved", header: "Resolved", width: 10 },
+  { key: "date", header: "Date", width: 15 }
+];
+function resolveParent(opts) {
+  const parents = [];
+  if (opts.taskId) parents.push({ type: "task", id: opts.taskId });
+  if (opts.listId) parents.push({ type: "list", id: opts.listId });
+  if (opts.viewId) parents.push({ type: "view", id: opts.viewId });
+  if (parents.length === 0) {
+    process.stderr.write("Error: Provide one of --task-id, --list-id, or --view-id.\n");
+    process.exit(2);
+    return void 0;
+  }
+  if (parents.length > 1) {
+    process.stderr.write("Error: Provide only one of --task-id, --list-id, or --view-id.\n");
+    process.exit(2);
+    return void 0;
+  }
+  return parents[0];
+}
+function formatComments(comments) {
+  return comments.map((c) => ({
+    ...c,
+    user_name: c["user"]?.["username"] ?? "",
+    assignee_name: c["assignee"]?.["username"] ?? ""
+  }));
+}
+function registerCommentCommands(program, getClient) {
+  const comment = program.command("comment").description("Manage comments");
+  comment.command("list").description("List comments on a task, list, or view").option("--task-id <id>", "Task ID").option("--list-id <id>", "List ID").option("--view-id <id>", "View ID").option("--start <ts>", "Pagination: start after this Unix ms timestamp").option("--start-id <id>", "Pagination: start after this comment ID").action(async (opts) => {
+    const parent = resolveParent(opts);
+    if (!parent) return;
+    const client = getClient();
+    const params = {};
+    if (opts.start) params["start"] = opts.start;
+    if (opts.startId) params["start_id"] = opts.startId;
+    const data = await client.get(`/${parent.type}/${parent.id}/comment`, params);
+    formatOutput(formatComments(data.comments), COMMENT_COLUMNS, getOutputOptions(program));
+  });
+  comment.command("create").description("Create a comment on a task, list, or view").option("--task-id <id>", "Task ID").option("--list-id <id>", "List ID").option("--view-id <id>", "View ID").requiredOption("--text <text>", "Comment text").option("--assignee <id>", "Assignee user ID").option("--notify-all", "Notify all watchers").action(async (opts) => {
+    const parent = resolveParent(opts);
+    if (!parent) return;
+    const client = getClient();
+    const body = { comment_text: opts.text };
+    if (opts.assignee !== void 0) body["assignee"] = parseInt(opts.assignee, 10);
+    if (opts.notifyAll) body["notify_all"] = true;
+    const data = await client.post(`/${parent.type}/${parent.id}/comment`, body);
+    process.stdout.write(`Created comment ${data["id"] ?? ""}
+`);
+  });
+  comment.command("update").description("Update a comment").argument("<comment-id>", "Comment ID").requiredOption("--text <text>", "New comment text").option("--assignee <id>", "Assignee user ID").option("--resolved <bool>", "Mark as resolved (true/false)").action(async (commentId, opts) => {
+    const client = getClient();
+    const body = { comment_text: opts.text };
+    if (opts.assignee !== void 0) body["assignee"] = parseInt(opts.assignee, 10);
+    if (opts.resolved !== void 0) body["resolved"] = opts.resolved === "true";
+    await client.put(`/comment/${commentId}`, body);
+    process.stdout.write(`Updated comment ${commentId}
+`);
+  });
+  comment.command("delete").description("Delete a comment").argument("<comment-id>", "Comment ID").option("--confirm", "Skip confirmation prompt").action(async (commentId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete comment ${commentId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/comment/${commentId}`);
+    process.stdout.write(`Deleted comment ${commentId}
+`);
+  });
+  comment.command("list-threaded").description("List threaded replies to a comment").argument("<comment-id>", "Comment ID").action(async (commentId) => {
+    const client = getClient();
+    const data = await client.get(`/comment/${commentId}/thread`);
+    formatOutput(formatComments(data.comments), COMMENT_COLUMNS, getOutputOptions(program));
+  });
+  comment.command("reply").description("Reply to a comment (threaded)").argument("<comment-id>", "Comment ID").requiredOption("--text <text>", "Reply text").option("--assignee <id>", "Assignee user ID").option("--notify-all", "Notify all watchers").action(async (commentId, opts) => {
+    const client = getClient();
+    const body = { comment_text: opts.text };
+    if (opts.assignee !== void 0) body["assignee"] = parseInt(opts.assignee, 10);
+    if (opts.notifyAll) body["notify_all"] = true;
+    const data = await client.post(`/comment/${commentId}/thread`, body);
+    process.stdout.write(`Created reply ${data["id"] ?? ""}
+`);
+  });
+}
+
+// src/commands/time-tracking.ts
+init_config();
+
+// src/dates.ts
+var RELATIVE_OFFSET_RE = /^([+-]\d+)([dwmh])$/;
+var UNIX_MS_RE = /^\d{13,}$/;
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+var DAY_NAMES = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+function parseDate(input) {
+  const raw = input.trim();
+  const lower = raw.toLowerCase();
+  if (UNIX_MS_RE.test(raw)) {
+    return parseInt(raw, 10);
+  }
+  const now = /* @__PURE__ */ new Date();
+  switch (lower) {
+    case "today": {
+      return startOfDay(now).getTime();
+    }
+    case "tomorrow": {
+      const d = startOfDay(now);
+      d.setDate(d.getDate() + 1);
+      return d.getTime();
+    }
+    case "yesterday": {
+      const d = startOfDay(now);
+      d.setDate(d.getDate() - 1);
+      return d.getTime();
+    }
+  }
+  const offsetMatch = RELATIVE_OFFSET_RE.exec(lower);
+  if (offsetMatch) {
+    const amount = parseInt(offsetMatch[1], 10);
+    const unit = offsetMatch[2];
+    const ms = unitToMs(unit, amount);
+    return now.getTime() + ms;
+  }
+  if (lower.startsWith("next ")) {
+    const dayName = lower.slice(5);
+    const dayIndex = DAY_NAMES.indexOf(dayName);
+    if (dayIndex !== -1) {
+      const today = now.getDay();
+      let daysAhead = dayIndex - today;
+      if (daysAhead <= 0) daysAhead += 7;
+      const target = startOfDay(now);
+      target.setDate(target.getDate() + daysAhead);
+      return target.getTime();
+    }
+  }
+  if (ISO_DATE_RE.test(raw)) {
+    const d = /* @__PURE__ */ new Date(raw + "T00:00:00");
+    if (!isNaN(d.getTime())) return d.getTime();
+  }
+  if (ISO_DATETIME_RE.test(raw)) {
+    const d = new Date(raw);
+    if (!isNaN(d.getTime())) return d.getTime();
+  }
+  throw new Error(`Unable to parse date: "${input}"`);
+}
+function startOfDay(date) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function unitToMs(unit, amount) {
+  switch (unit) {
+    case "m":
+      return amount * 60 * 1e3;
+    case "h":
+      return amount * 60 * 60 * 1e3;
+    case "d":
+      return amount * 24 * 60 * 60 * 1e3;
+    case "w":
+      return amount * 7 * 24 * 60 * 60 * 1e3;
+    default:
+      return 0;
+  }
+}
+
+// src/commands/time-tracking.ts
+registerSchema("time", "list", "List time entries for a task or workspace", [
+  { flag: "--task-id", type: "string", required: false, description: "Task ID (or use --workspace-id for workspace-wide)" },
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID" },
+  { flag: "--start", type: "string", required: false, description: "Start date" },
+  { flag: "--end", type: "string", required: false, description: "End date" },
+  { flag: "--assignee", type: "string[]", required: false, description: "Assignee user ID (repeatable)" }
+]);
+registerSchema("time", "get", "Get a specific time entry", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<timer-id>", type: "string", required: true, description: "Time entry ID" }
+]);
+registerSchema("time", "create", "Create a time entry on a task", [
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--duration", type: "string", required: true, description: "Duration in milliseconds" },
+  { flag: "--start", type: "string", required: true, description: "Start time (Unix ms or date string)" },
+  { flag: "--description", type: "string", required: false, description: "Description" },
+  { flag: "--billable", type: "boolean", required: false, description: "Billable" },
+  { flag: "--tag", type: "string[]", required: false, description: "Tag name (repeatable)" }
+]);
+registerSchema("time", "update", "Update a time entry", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<timer-id>", type: "string", required: true, description: "Time entry ID" },
+  { flag: "--description", type: "string", required: false, description: "Description" },
+  { flag: "--duration", type: "string", required: false, description: "Duration in ms" },
+  { flag: "--start", type: "string", required: false, description: "Start time" },
+  { flag: "--billable", type: "boolean", required: false, description: "Billable" },
+  { flag: "--tag", type: "string[]", required: false, description: "Tag name (repeatable)" }
+]);
+registerSchema("time", "delete", "Delete a time entry", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<timer-id>", type: "string", required: true, description: "Time entry ID" }
+]);
+registerSchema("time", "running", "Get current running timer", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--assignee", type: "string", required: false, description: "Assignee user ID" }
+]);
+registerSchema("time", "start", "Start a running timer", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--description", type: "string", required: false, description: "Description" },
+  { flag: "--billable", type: "boolean", required: false, description: "Billable" }
+]);
+registerSchema("time", "stop", "Stop the running timer", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+registerSchema("time", "tags", "List time tracking tags", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+var TIME_ENTRY_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "task_id", header: "Task", width: 12 },
+  { key: "duration", header: "Duration", width: 12 },
+  { key: "start", header: "Start", width: 18 },
+  { key: "end", header: "End", width: 18 },
+  { key: "description", header: "Description", width: 25 },
+  { key: "billable", header: "Billable", width: 10 },
+  { key: "user_name", header: "User", width: 15 }
+];
+var TIME_TAG_COLUMNS = [
+  { key: "name", header: "Name", width: 25 },
+  { key: "creator", header: "Creator", width: 12 },
+  { key: "status", header: "Status", width: 12 }
+];
+var TIME_HISTORY_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "field", header: "Field", width: 15 },
+  { key: "before", header: "Before", width: 20 },
+  { key: "after", header: "After", width: 20 },
+  { key: "date", header: "Date", width: 18 }
+];
+function collect2(value, previous) {
+  return previous.concat([value]);
+}
+function requireWorkspaceId4(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function formatEntries(entries) {
+  return entries.map((e) => ({
+    ...e,
+    task_id: e["task"]?.["id"] ?? "",
+    user_name: e["user"]?.["username"] ?? ""
+  }));
+}
+function registerTimeTrackingCommands(program, getClient) {
+  const time = program.command("time").description("Manage time tracking");
+  time.command("list").description("List time entries (by task or workspace-wide)").option("--task-id <id>", "Task ID").option("--start <date>", "Start date (ISO 8601, relative, or Unix ms)").option("--end <date>", "End date").option("--assignee <id>", "Assignee user ID (repeatable)", collect2, []).action(async (opts) => {
+    const client = getClient();
+    if (opts.taskId) {
+      const data = await client.get(`/task/${opts.taskId}/time`);
+      formatOutput(formatEntries(data.data), TIME_ENTRY_COLUMNS, getOutputOptions(program));
+    } else {
+      const workspaceId = requireWorkspaceId4(program);
+      if (!workspaceId) return;
+      const params = {};
+      if (opts.start) params["start_date"] = String(parseDate(opts.start));
+      if (opts.end) params["end_date"] = String(parseDate(opts.end));
+      if (opts.assignee.length) params["assignee"] = opts.assignee;
+      const data = await client.get(`/team/${workspaceId}/time_entries`, params);
+      formatOutput(formatEntries(data.data), TIME_ENTRY_COLUMNS, getOutputOptions(program));
+    }
+  });
+  time.command("get").description("Get a specific time entry").argument("<timer-id>", "Time entry ID").action(async (timerId) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/time_entries/${timerId}`);
+    formatOutput(formatEntries([data.data]), TIME_ENTRY_COLUMNS, getOutputOptions(program));
+  });
+  time.command("create").description("Create a time entry on a task").requiredOption("--task-id <id>", "Task ID").requiredOption("--duration <ms>", "Duration in milliseconds").requiredOption("--start <ts>", "Start time (Unix ms or date string)").option("--description <desc>", "Description").option("--assignee <id>", "Assignee user ID").option("--billable <bool>", "Billable (true/false)").option("--tag <name>", "Tag name (repeatable)", collect2, []).action(async (opts) => {
+    const client = getClient();
+    const body = {
+      duration: parseInt(opts.duration, 10),
+      start: String(parseDate(opts.start))
+    };
+    if (opts.description !== void 0) body["description"] = opts.description;
+    if (opts.assignee !== void 0) body["assignee"] = parseInt(opts.assignee, 10);
+    if (opts.billable !== void 0) body["billable"] = opts.billable === "true";
+    if (opts.tag.length) body["tags"] = opts.tag.map((t) => ({ name: t }));
+    const data = await client.post(`/task/${opts.taskId}/time`, body);
+    process.stdout.write(`Created time entry ${data.data?.id ?? ""}
+`);
+  });
+  time.command("update").description("Update a time entry").argument("<timer-id>", "Time entry ID").option("--description <desc>", "Description").option("--duration <ms>", "Duration in milliseconds").option("--start <ts>", "Start time (Unix ms or date string)").option("--tag-action <action>", "Tag action (add or remove)").option("--tag <name>", "Tag name (repeatable)", collect2, []).option("--billable <bool>", "Billable (true/false)").action(async (timerId, opts) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = {};
+    if (opts.description !== void 0) body["description"] = opts.description;
+    if (opts.duration !== void 0) body["duration"] = parseInt(opts.duration, 10);
+    if (opts.start !== void 0) body["start"] = String(parseDate(opts.start));
+    if (opts.billable !== void 0) body["billable"] = opts.billable === "true";
+    if (opts.tag.length) {
+      body["tags"] = opts.tag.map((t) => ({ name: t }));
+      if (opts.tagAction) body["tag_action"] = opts.tagAction;
+    }
+    await client.put(`/team/${workspaceId}/time_entries/${timerId}`, body);
+    process.stdout.write(`Updated time entry ${timerId}
+`);
+  });
+  time.command("delete").description("Delete a time entry").argument("<timer-id>", "Time entry ID").action(async (timerId) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    await client.delete(`/team/${workspaceId}/time_entries/${timerId}`);
+    process.stdout.write(`Deleted time entry ${timerId}
+`);
+  });
+  time.command("history").description("Get time entry change history").argument("<timer-id>", "Time entry ID").action(async (timerId) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/time_entries/${timerId}/history`);
+    formatOutput(data.data, TIME_HISTORY_COLUMNS, getOutputOptions(program));
+  });
+  time.command("running").description("Get current running timer").option("--assignee <id>", "Assignee user ID").action(async (opts) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const params = {};
+    if (opts.assignee) params["assignee"] = opts.assignee;
+    const data = await client.get(`/team/${workspaceId}/time_entries/current`, params);
+    if (data.data) {
+      formatOutput(formatEntries([data.data]), TIME_ENTRY_COLUMNS, getOutputOptions(program));
+    } else {
+      process.stdout.write("No running timer.\n");
+    }
+  });
+  time.command("start").description("Start a running timer").requiredOption("--task-id <id>", "Task ID").option("--description <desc>", "Description").option("--billable <bool>", "Billable (true/false)").option("--tag <name>", "Tag name (repeatable)", collect2, []).action(async (opts) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { tid: opts.taskId };
+    if (opts.description !== void 0) body["description"] = opts.description;
+    if (opts.billable !== void 0) body["billable"] = opts.billable === "true";
+    if (opts.tag.length) body["tags"] = opts.tag.map((t) => ({ name: t }));
+    const data = await client.post(`/team/${workspaceId}/time_entries/start`, body);
+    process.stdout.write(`Started timer ${data.data?.id ?? ""}
+`);
+  });
+  time.command("stop").description("Stop the running timer").action(async () => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.post(`/team/${workspaceId}/time_entries/stop`);
+    process.stdout.write(`Stopped timer ${data.data?.id ?? ""}
+`);
+  });
+  time.command("tags").description("List time tracking tags").action(async () => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/time_entries/tags`);
+    formatOutput(data.data, TIME_TAG_COLUMNS, getOutputOptions(program));
+  });
+  time.command("add-tags").description("Add tags to time entries").option("--timer-id <id>", "Time entry ID (repeatable)", collect2, []).option("--tag <name>", "Tag name (repeatable)", collect2, []).action(async (opts) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    if (!opts.timerId.length || !opts.tag.length) {
+      process.stderr.write("Error: --timer-id and --tag are required.\n");
+      process.exit(2);
+      return;
+    }
+    await client.post(`/team/${workspaceId}/time_entries/tags`, {
+      time_entry_ids: opts.timerId,
+      tags: opts.tag.map((t) => ({ name: t }))
+    });
+    process.stdout.write(`Added tags to ${opts.timerId.length} time entries.
+`);
+  });
+  time.command("remove-tags").description("Remove tags from time entries").option("--timer-id <id>", "Time entry ID (repeatable)", collect2, []).option("--tag <name>", "Tag name (repeatable)", collect2, []).action(async (opts) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    if (!opts.timerId.length || !opts.tag.length) {
+      process.stderr.write("Error: --timer-id and --tag are required.\n");
+      process.exit(2);
+      return;
+    }
+    await client.delete(`/team/${workspaceId}/time_entries/tags`, {
+      time_entry_ids: opts.timerId,
+      tags: opts.tag.map((t) => ({ name: t }))
+    });
+    process.stdout.write(`Removed tags from ${opts.timerId.length} time entries.
+`);
+  });
+  time.command("rename-tag").description("Rename a time tracking tag").requiredOption("--name <name>", "Current tag name").requiredOption("--new-name <name>", "New tag name").action(async (opts) => {
+    const workspaceId = requireWorkspaceId4(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    await client.put(`/team/${workspaceId}/time_entries/tags`, {
+      name: opts.name,
+      new_name: opts.newName
+    });
+    process.stdout.write(`Renamed tag "${opts.name}" to "${opts.newName}"
+`);
+  });
+}
+
+// src/commands/goal.ts
+init_config();
+registerSchema("goal", "list", "List goals in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--include-completed", type: "boolean", required: false, description: "Include completed goals" }
+]);
+registerSchema("goal", "get", "Get a goal", [
+  { flag: "<goal-id>", type: "string", required: true, description: "Goal ID" }
+]);
+registerSchema("goal", "create", "Create a goal", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--name", type: "string", required: true, description: "Goal name" },
+  { flag: "--due-date", type: "string", required: false, description: "Due date (Unix ms)" },
+  { flag: "--description", type: "string", required: false, description: "Description" },
+  { flag: "--multiple-owners", type: "boolean", required: false, description: "Allow multiple owners" },
+  { flag: "--owner", type: "string[]", required: false, description: "Owner user ID (repeatable)" },
+  { flag: "--color", type: "string", required: false, description: "Color hex code" }
+]);
+registerSchema("goal", "update", "Update a goal", [
+  { flag: "<goal-id>", type: "string", required: true, description: "Goal ID" },
+  { flag: "--name", type: "string", required: false, description: "Goal name" },
+  { flag: "--due-date", type: "string", required: false, description: "Due date (Unix ms)" },
+  { flag: "--description", type: "string", required: false, description: "Description" },
+  { flag: "--color", type: "string", required: false, description: "Color hex code" }
+]);
+registerSchema("goal", "delete", "Delete a goal", [
+  { flag: "<goal-id>", type: "string", required: true, description: "Goal ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("goal", "add-key-result", "Add a key result to a goal", [
+  { flag: "<goal-id>", type: "string", required: true, description: "Goal ID" },
+  { flag: "--name", type: "string", required: true, description: "Key result name" },
+  { flag: "--type", type: "string", required: true, description: "Type (number, currency, boolean, percentage, automatic)" },
+  { flag: "--steps-start", type: "string", required: false, description: "Starting value" },
+  { flag: "--steps-end", type: "string", required: false, description: "Target value" },
+  { flag: "--unit", type: "string", required: false, description: "Unit label" }
+]);
+registerSchema("goal", "update-key-result", "Update a key result", [
+  { flag: "<key-result-id>", type: "string", required: true, description: "Key result ID" },
+  { flag: "--name", type: "string", required: false, description: "Key result name" },
+  { flag: "--steps-current", type: "string", required: false, description: "Current value" },
+  { flag: "--note", type: "string", required: false, description: "Progress note" }
+]);
+registerSchema("goal", "delete-key-result", "Delete a key result", [
+  { flag: "<key-result-id>", type: "string", required: true, description: "Key result ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+var GOAL_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "description", header: "Description", width: 25 },
+  { key: "due_date", header: "Due Date", width: 15 },
+  { key: "color", header: "Color", width: 10 },
+  { key: "percent_completed", header: "% Done", width: 8 },
+  { key: "owner_names", header: "Owners", width: 20 }
+];
+function collect3(value, previous) {
+  return previous.concat([value]);
+}
+function requireWorkspaceId5(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function formatGoals(goals) {
+  return goals.map((g) => ({
+    ...g,
+    owner_names: Array.isArray(g["owners"]) ? g["owners"].map((o) => o["username"] ?? "").join(", ") : ""
+  }));
+}
+function registerGoalCommands(program, getClient) {
+  const goal = program.command("goal").description("Manage goals");
+  goal.command("list").description("List goals").option("--include-completed", "Include completed goals").action(async (opts) => {
+    const workspaceId = requireWorkspaceId5(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const params = {};
+    if (opts.includeCompleted) params["include_completed"] = "true";
+    const data = await client.get(`/team/${workspaceId}/goal`, params);
+    formatOutput(formatGoals(data.goals), GOAL_COLUMNS, getOutputOptions(program));
+  });
+  goal.command("get").description("Get a goal").argument("<goal-id>", "Goal ID").action(async (goalId) => {
+    const client = getClient();
+    const data = await client.get(`/goal/${goalId}`);
+    formatOutput(formatGoals([data.goal]), GOAL_COLUMNS, getOutputOptions(program));
+  });
+  goal.command("create").description("Create a goal").requiredOption("--name <name>", "Goal name").option("--due-date <date>", "Due date (Unix ms)").option("--description <desc>", "Description").option("--multiple-owners", "Allow multiple owners").option("--owner <id>", "Owner user ID (repeatable)", collect3, []).option("--color <color>", "Color hex code").action(async (opts) => {
+    const workspaceId = requireWorkspaceId5(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.dueDate !== void 0) body["due_date"] = opts.dueDate;
+    if (opts.description !== void 0) body["description"] = opts.description;
+    if (opts.multipleOwners) body["multiple_owners"] = true;
+    if (opts.owner.length) body["owners"] = opts.owner.map((id) => parseInt(id, 10));
+    if (opts.color !== void 0) body["color"] = opts.color;
+    const data = await client.post(`/team/${workspaceId}/goal`, body);
+    process.stdout.write(`Created goal ${data.goal?.id ?? ""}
+`);
+  });
+  goal.command("update").description("Update a goal").argument("<goal-id>", "Goal ID").option("--name <name>", "Goal name").option("--due-date <date>", "Due date (Unix ms)").option("--description <desc>", "Description").option("--color <color>", "Color hex code").action(async (goalId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.dueDate !== void 0) body["due_date"] = opts.dueDate;
+    if (opts.description !== void 0) body["description"] = opts.description;
+    if (opts.color !== void 0) body["color"] = opts.color;
+    await client.put(`/goal/${goalId}`, body);
+    process.stdout.write(`Updated goal ${goalId}
+`);
+  });
+  goal.command("delete").description("Delete a goal").argument("<goal-id>", "Goal ID").option("--confirm", "Skip confirmation prompt").action(async (goalId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete goal ${goalId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/goal/${goalId}`);
+    process.stdout.write(`Deleted goal ${goalId}
+`);
+  });
+  goal.command("add-key-result").description("Add a key result to a goal").argument("<goal-id>", "Goal ID").requiredOption("--name <name>", "Key result name").requiredOption("--type <type>", "Type (number, currency, boolean, percentage, automatic)").option("--steps-start <n>", "Starting value").option("--steps-end <n>", "Target value").option("--unit <unit>", "Unit label").option("--task-ids <id>", "Task ID (repeatable, for automatic type)", collect3, []).option("--list-ids <id>", "List ID (repeatable, for automatic type)", collect3, []).action(async (goalId, opts) => {
+    const client = getClient();
+    const body = { name: opts.name, type: opts.type };
+    if (opts.stepsStart !== void 0) body["steps_start"] = parseFloat(opts.stepsStart);
+    if (opts.stepsEnd !== void 0) body["steps_end"] = parseFloat(opts.stepsEnd);
+    if (opts.unit !== void 0) body["unit"] = opts.unit;
+    if (opts.taskIds.length) body["task_ids"] = opts.taskIds;
+    if (opts.listIds.length) body["list_ids"] = opts.listIds;
+    const data = await client.post(`/goal/${goalId}/key_result`, body);
+    process.stdout.write(`Created key result ${data.key_result?.id ?? ""}
+`);
+  });
+  goal.command("update-key-result").description("Update a key result").argument("<key-result-id>", "Key result ID").option("--name <name>", "Key result name").option("--steps-current <n>", "Current value").option("--note <note>", "Progress note").action(async (keyResultId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.stepsCurrent !== void 0) body["steps_current"] = parseFloat(opts.stepsCurrent);
+    if (opts.note !== void 0) body["note"] = opts.note;
+    await client.put(`/key_result/${keyResultId}`, body);
+    process.stdout.write(`Updated key result ${keyResultId}
+`);
+  });
+  goal.command("delete-key-result").description("Delete a key result").argument("<key-result-id>", "Key result ID").option("--confirm", "Skip confirmation prompt").action(async (keyResultId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete key result ${keyResultId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/key_result/${keyResultId}`);
+    process.stdout.write(`Deleted key result ${keyResultId}
+`);
+  });
+}
+
+// src/commands/view.ts
+registerSchema("view", "list", "List views for a workspace, space, folder, or list", [
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID (provide one parent)" },
+  { flag: "--space-id", type: "string", required: false, description: "Space ID (provide one parent)" },
+  { flag: "--folder-id", type: "string", required: false, description: "Folder ID (provide one parent)" },
+  { flag: "--list-id", type: "string", required: false, description: "List ID (provide one parent)" }
+]);
+registerSchema("view", "get", "Get a view", [
+  { flag: "<view-id>", type: "string", required: true, description: "View ID" }
+]);
+registerSchema("view", "create", "Create a view", [
+  { flag: "--space-id", type: "string", required: false, description: "Space ID (provide one parent)" },
+  { flag: "--folder-id", type: "string", required: false, description: "Folder ID (provide one parent)" },
+  { flag: "--list-id", type: "string", required: false, description: "List ID (provide one parent)" },
+  { flag: "--name", type: "string", required: true, description: "View name" },
+  { flag: "--type", type: "string", required: true, description: "View type (list, board, calendar, etc.)" }
+]);
+registerSchema("view", "update", "Update a view", [
+  { flag: "<view-id>", type: "string", required: true, description: "View ID" },
+  { flag: "--name", type: "string", required: false, description: "View name" },
+  { flag: "--settings", type: "string", required: false, description: "Settings (JSON string)" },
+  { flag: "--grouping", type: "string", required: false, description: "Grouping config (JSON string)" },
+  { flag: "--sorting", type: "string", required: false, description: "Sorting config (JSON string)" },
+  { flag: "--filters", type: "string", required: false, description: "Filters config (JSON string)" }
+]);
+registerSchema("view", "delete", "Delete a view", [
+  { flag: "<view-id>", type: "string", required: true, description: "View ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("view", "tasks", "Get tasks in a view", [
+  { flag: "<view-id>", type: "string", required: true, description: "View ID" },
+  { flag: "--page", type: "string", required: false, description: "Page number (zero-indexed)" }
+]);
+var VIEW_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "type", header: "Type", width: 12 },
+  { key: "date_created", header: "Created", width: 15 },
+  { key: "creator_name", header: "Creator", width: 15 }
+];
+var VIEW_TASK_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "name", header: "Name", width: 35 },
+  { key: "status_name", header: "Status", width: 15 },
+  { key: "assignee_names", header: "Assignees", width: 20 }
+];
+function resolveViewParent(opts, program) {
+  const parents = [];
+  const globalWsId = program.opts()["workspaceId"];
+  if (globalWsId) parents.push({ segment: "team", id: globalWsId });
+  if (opts.spaceId) parents.push({ segment: "space", id: opts.spaceId });
+  if (opts.folderId) parents.push({ segment: "folder", id: opts.folderId });
+  if (opts.listId) parents.push({ segment: "list", id: opts.listId });
+  if (parents.length === 0) {
+    process.stderr.write("Error: Provide one of --workspace-id, --space-id, --folder-id, or --list-id.\n");
+    process.exit(2);
+    return void 0;
+  }
+  if (parents.length > 1) {
+    process.stderr.write("Error: Provide only one of --workspace-id, --space-id, --folder-id, or --list-id.\n");
+    process.exit(2);
+    return void 0;
+  }
+  return parents[0];
+}
+function formatViews(views) {
+  return views.map((v) => ({
+    ...v,
+    creator_name: v["creator"]?.["username"] ?? ""
+  }));
+}
+function formatViewTasks(tasks) {
+  return tasks.map((t) => ({
+    ...t,
+    status_name: t["status"]?.["status"] ?? "",
+    assignee_names: Array.isArray(t["assignees"]) ? t["assignees"].map((a) => a["username"] ?? "").join(", ") : ""
+  }));
+}
+function registerViewCommands(program, getClient) {
+  const view = program.command("view").description("Manage views");
+  view.command("list").description("List views for a workspace, space, folder, or list").option("--space-id <id>", "Space ID").option("--folder-id <id>", "Folder ID").option("--list-id <id>", "List ID").action(async (opts) => {
+    const parent = resolveViewParent(opts, program);
+    if (!parent) return;
+    const client = getClient();
+    const data = await client.get(`/${parent.segment}/${parent.id}/view`);
+    formatOutput(formatViews(data.views), VIEW_COLUMNS, getOutputOptions(program));
+  });
+  view.command("get").description("Get a view").argument("<view-id>", "View ID").action(async (viewId) => {
+    const client = getClient();
+    const data = await client.get(`/view/${viewId}`);
+    formatOutput(formatViews([data.view]), VIEW_COLUMNS, getOutputOptions(program));
+  });
+  view.command("create").description("Create a view").option("--space-id <id>", "Space ID").option("--folder-id <id>", "Folder ID").option("--list-id <id>", "List ID").requiredOption("--name <name>", "View name").requiredOption("--type <type>", "View type (list, board, calendar, gantt, table, timeline, activity, map, workload)").action(async (opts) => {
+    const parent = resolveViewParent(opts, program);
+    if (!parent) return;
+    const client = getClient();
+    const body = { name: opts.name, type: opts.type };
+    const data = await client.post(`/${parent.segment}/${parent.id}/view`, body);
+    process.stdout.write(`Created view ${data.view?.id ?? ""}
+`);
+  });
+  view.command("update").description("Update a view").argument("<view-id>", "View ID").option("--name <name>", "View name").option("--settings <json>", "Settings (JSON string)").option("--grouping <json>", "Grouping config (JSON string)").option("--sorting <json>", "Sorting config (JSON string)").option("--filters <json>", "Filters config (JSON string)").action(async (viewId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    for (const field of ["settings", "grouping", "sorting", "filters"]) {
+      if (opts[field] !== void 0) {
+        try {
+          body[field] = JSON.parse(opts[field]);
+        } catch {
+          process.stderr.write(`Error: Invalid JSON for --${field}.
+`);
+          process.exit(2);
+          return;
+        }
+      }
+    }
+    await client.put(`/view/${viewId}`, body);
+    process.stdout.write(`Updated view ${viewId}
+`);
+  });
+  view.command("delete").description("Delete a view").argument("<view-id>", "View ID").option("--confirm", "Skip confirmation prompt").action(async (viewId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete view ${viewId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/view/${viewId}`);
+    process.stdout.write(`Deleted view ${viewId}
+`);
+  });
+  view.command("tasks").description("Get tasks in a view").argument("<view-id>", "View ID").option("--page <n>", "Page number (zero-indexed)").action(async (viewId, opts) => {
+    const client = getClient();
+    const params = {};
+    if (opts.page !== void 0) params["page"] = opts.page;
+    const data = await client.get(`/view/${viewId}/task`, params);
+    formatOutput(formatViewTasks(data.tasks), VIEW_TASK_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/webhook.ts
+init_config();
+registerSchema("webhook", "list", "List webhooks in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+registerSchema("webhook", "create", "Create a webhook", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--endpoint", type: "string", required: true, description: "Webhook endpoint URL" },
+  { flag: "--event", type: "string[]", required: false, description: "Event to subscribe to (repeatable)" },
+  { flag: "--space-id", type: "string", required: false, description: "Scope to space" },
+  { flag: "--folder-id", type: "string", required: false, description: "Scope to folder" },
+  { flag: "--list-id", type: "string", required: false, description: "Scope to list" },
+  { flag: "--task-id", type: "string", required: false, description: "Scope to task" }
+]);
+registerSchema("webhook", "update", "Update a webhook", [
+  { flag: "<webhook-id>", type: "string", required: true, description: "Webhook ID" },
+  { flag: "--endpoint", type: "string", required: false, description: "New endpoint URL" },
+  { flag: "--event", type: "string[]", required: false, description: "Events (repeatable, replaces existing)" },
+  { flag: "--status", type: "string", required: false, description: "Status (active or inactive)" }
+]);
+registerSchema("webhook", "delete", "Delete a webhook", [
+  { flag: "<webhook-id>", type: "string", required: true, description: "Webhook ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("webhook", "events", "List available webhook event types", []);
+var WEBHOOK_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "endpoint", header: "Endpoint", width: 40 },
+  { key: "events_count", header: "Events", width: 8 },
+  { key: "health_status", header: "Health", width: 10 }
+];
+var WEBHOOK_EVENTS = [
+  "taskCreated",
+  "taskUpdated",
+  "taskDeleted",
+  "taskPriorityUpdated",
+  "taskStatusUpdated",
+  "taskAssigneeUpdated",
+  "taskDueDateUpdated",
+  "taskTagUpdated",
+  "taskMoved",
+  "taskCommentPosted",
+  "taskCommentUpdated",
+  "taskTimeEstimateUpdated",
+  "taskTimeTrackedUpdated",
+  "listCreated",
+  "listUpdated",
+  "listDeleted",
+  "folderCreated",
+  "folderUpdated",
+  "folderDeleted",
+  "spaceCreated",
+  "spaceUpdated",
+  "spaceDeleted",
+  "goalCreated",
+  "goalUpdated",
+  "goalDeleted",
+  "goalKeyResultCreated",
+  "goalKeyResultUpdated",
+  "goalKeyResultDeleted"
+];
+function collect4(value, previous) {
+  return previous.concat([value]);
+}
+function requireWorkspaceId6(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function formatWebhooks(webhooks) {
+  return webhooks.map((w) => ({
+    ...w,
+    events_count: Array.isArray(w["events"]) ? w["events"].length : 0,
+    health_status: w["health"]?.["status"] ?? "unknown"
+  }));
+}
+function registerWebhookCommands(program, getClient) {
+  const webhook = program.command("webhook").description("Manage webhooks");
+  webhook.command("list").description("List webhooks").action(async () => {
+    const workspaceId = requireWorkspaceId6(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/webhook`);
+    formatOutput(formatWebhooks(data.webhooks), WEBHOOK_COLUMNS, getOutputOptions(program));
+  });
+  webhook.command("create").description("Create a webhook").requiredOption("--endpoint <url>", "Webhook endpoint URL").option("--event <event>", "Event to subscribe to (repeatable)", collect4, []).option("--space-id <id>", "Scope to space").option("--folder-id <id>", "Scope to folder").option("--list-id <id>", "Scope to list").option("--task-id <id>", "Scope to task").action(async (opts) => {
+    const workspaceId = requireWorkspaceId6(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = {
+      endpoint: opts.endpoint,
+      events: opts.event
+    };
+    if (opts.spaceId !== void 0) body["space_id"] = opts.spaceId;
+    if (opts.folderId !== void 0) body["folder_id"] = opts.folderId;
+    if (opts.listId !== void 0) body["list_id"] = opts.listId;
+    if (opts.taskId !== void 0) body["task_id"] = opts.taskId;
+    const data = await client.post(`/team/${workspaceId}/webhook`, body);
+    process.stdout.write(`Created webhook ${data.id ?? ""}
+`);
+  });
+  webhook.command("update").description("Update a webhook").argument("<webhook-id>", "Webhook ID").option("--endpoint <url>", "New endpoint URL").option("--event <event>", "Event to subscribe to (repeatable, replaces existing)", collect4, []).option("--status <status>", "Status (active or inactive)").action(async (webhookId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.endpoint !== void 0) body["endpoint"] = opts.endpoint;
+    if (opts.event.length) body["events"] = opts.event;
+    if (opts.status !== void 0) body["status"] = opts.status;
+    await client.put(`/webhook/${webhookId}`, body);
+    process.stdout.write(`Updated webhook ${webhookId}
+`);
+  });
+  webhook.command("delete").description("Delete a webhook").argument("<webhook-id>", "Webhook ID").option("--confirm", "Skip confirmation prompt").action(async (webhookId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete webhook ${webhookId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/webhook/${webhookId}`);
+    process.stdout.write(`Deleted webhook ${webhookId}
+`);
+  });
+  webhook.command("events").description("List available webhook event types").action(() => {
+    const rows = WEBHOOK_EVENTS.map((e) => ({ event: e }));
+    formatOutput(rows, [{ key: "event", header: "Event", width: 35 }], getOutputOptions(program));
+  });
+}
+
+// src/commands/user.ts
+init_config();
+var USER_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "username", header: "Username", width: 20 },
+  { key: "email", header: "Email", width: 30 },
+  { key: "role", header: "Role", width: 8 },
+  { key: "custom_role_id", header: "Custom Role", width: 14 }
+];
+function requireWorkspaceId7(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+registerSchema("user", "invite", "Invite a user to a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--email", type: "string", required: true, description: "Email address to invite" },
+  { flag: "--admin", type: "boolean", required: false, description: "Make the user an admin" }
+]);
+registerSchema("user", "get", "Get a user in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<user-id>", type: "string", required: true, description: "User ID" }
+]);
+registerSchema("user", "update", "Update a user in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<user-id>", type: "string", required: true, description: "User ID" },
+  { flag: "--username", type: "string", required: false, description: "New username" },
+  { flag: "--admin", type: "boolean", required: false, description: "Set admin status" },
+  { flag: "--custom-role-id", type: "integer", required: false, description: "Custom role ID" }
+]);
+registerSchema("user", "remove", "Remove a user from a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<user-id>", type: "string", required: true, description: "User ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+function registerUserCommands(program, getClient) {
+  const user = program.command("user").description("Manage workspace users");
+  user.command("invite").description("Invite a user to a workspace").requiredOption("--email <email>", "Email address to invite").option("--admin <bool>", "Make the user an admin").action(async (opts) => {
+    const workspaceId = requireWorkspaceId7(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { email: opts.email };
+    if (opts.admin !== void 0) body["admin"] = opts.admin === "true";
+    const data = await client.post(`/team/${workspaceId}/user`, body);
+    process.stdout.write(`Invited ${opts.email} to workspace ${data.team?.id ?? workspaceId}
+`);
+  });
+  user.command("get").description("Get a user in a workspace").argument("<user-id>", "User ID").action(async (userId) => {
+    const workspaceId = requireWorkspaceId7(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/user/${userId}`);
+    const userObj = data.member?.user ?? data.member;
+    formatOutput(userObj, USER_COLUMNS, getOutputOptions(program));
+  });
+  user.command("update").description("Update a user in a workspace").argument("<user-id>", "User ID").option("--username <name>", "New username").option("--admin <bool>", "Set admin status").option("--custom-role-id <id>", "Custom role ID").action(async (userId, opts) => {
+    const workspaceId = requireWorkspaceId7(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = {};
+    if (opts.username !== void 0) body["username"] = opts.username;
+    if (opts.admin !== void 0) body["admin"] = opts.admin === "true";
+    if (opts.customRoleId !== void 0) body["custom_role_id"] = parseInt(opts.customRoleId, 10);
+    await client.put(`/team/${workspaceId}/user/${userId}`, body);
+    process.stdout.write(`Updated user ${userId}
+`);
+  });
+  user.command("remove").description("Remove a user from a workspace").argument("<user-id>", "User ID").option("--confirm", "Skip confirmation prompt").action(async (userId, opts) => {
+    const workspaceId = requireWorkspaceId7(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to remove in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Remove user ${userId} from workspace?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/team/${workspaceId}/user/${userId}`);
+    process.stdout.write(`Removed user ${userId}
+`);
+  });
+}
+
+// src/commands/group.ts
+init_config();
+var GROUP_COLUMNS = [
+  { key: "id", header: "ID", width: 14 },
+  { key: "name", header: "Name", width: 25 },
+  { key: "member_count", header: "Members", width: 10 },
+  { key: "date_created", header: "Created", width: 15 }
+];
+function collect5(value, previous) {
+  return previous.concat([value]);
+}
+function requireWorkspaceId8(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+registerSchema("group", "list", "List user groups in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--group-id", type: "string[]", required: false, description: "Filter by group IDs (repeatable)" }
+]);
+registerSchema("group", "create", "Create a user group", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--name", type: "string", required: true, description: "Group name" },
+  { flag: "--member-id", type: "integer[]", required: false, description: "Member user IDs (repeatable)" }
+]);
+registerSchema("group", "update", "Update a user group", [
+  { flag: "<group-id>", type: "string", required: true, description: "Group ID" },
+  { flag: "--name", type: "string", required: false, description: "New group name" },
+  { flag: "--add-member", type: "integer[]", required: false, description: "User IDs to add (repeatable)" },
+  { flag: "--remove-member", type: "integer[]", required: false, description: "User IDs to remove (repeatable)" }
+]);
+registerSchema("group", "delete", "Delete a user group", [
+  { flag: "<group-id>", type: "string", required: true, description: "Group ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+function registerGroupCommands(program, getClient) {
+  const group = program.command("group").description("Manage user groups");
+  group.command("list").description("List user groups").option("--group-id <id>", "Filter by group ID (repeatable)", collect5, []).action(async (opts) => {
+    const workspaceId = requireWorkspaceId8(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const params = {};
+    if (opts.groupId.length) params["group_ids"] = opts.groupId.join(",");
+    const data = await client.get(`/team/${workspaceId}/group`, params);
+    const rows = data.groups.map((g) => ({
+      ...g,
+      member_count: Array.isArray(g.members) ? g.members.length : 0
+    }));
+    formatOutput(rows, GROUP_COLUMNS, getOutputOptions(program));
+  });
+  group.command("create").description("Create a user group").requiredOption("--name <name>", "Group name").option("--member-id <id>", "Member user ID (repeatable)", collect5, []).action(async (opts) => {
+    const workspaceId = requireWorkspaceId8(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.memberId.length) {
+      body["members"] = opts.memberId.map((id) => ({ id: parseInt(id, 10) }));
+    }
+    const data = await client.post(`/team/${workspaceId}/group`, body);
+    process.stdout.write(`Created group ${data["id"] ?? ""}
+`);
+  });
+  group.command("update").description("Update a user group").argument("<group-id>", "Group ID").option("--name <name>", "New group name").option("--add-member <id>", "User ID to add (repeatable)", collect5, []).option("--remove-member <id>", "User ID to remove (repeatable)", collect5, []).action(async (groupId, opts) => {
+    const client = getClient();
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    const members = {};
+    if (opts.addMember.length) members["add"] = opts.addMember.map((id) => ({ id: parseInt(id, 10) }));
+    if (opts.removeMember.length) members["rem"] = opts.removeMember.map((id) => ({ id: parseInt(id, 10) }));
+    if (Object.keys(members).length) body["members"] = members;
+    await client.put(`/group/${groupId}`, body);
+    process.stdout.write(`Updated group ${groupId}
+`);
+  });
+  group.command("delete").description("Delete a user group").argument("<group-id>", "Group ID").option("--confirm", "Skip confirmation prompt").action(async (groupId, opts) => {
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete group ${groupId}?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/group/${groupId}`);
+    process.stdout.write(`Deleted group ${groupId}
+`);
+  });
+}
+
+// src/commands/guest.ts
+init_config();
+var GUEST_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "username", header: "Username", width: 20 },
+  { key: "email", header: "Email", width: 30 },
+  { key: "can_edit_tags", header: "Edit Tags", width: 10 },
+  { key: "can_see_time_spent", header: "See Time", width: 10 },
+  { key: "can_see_time_estimated", header: "See Est.", width: 10 }
+];
+function requireWorkspaceId9(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function parseBool(val) {
+  if (val === void 0) return void 0;
+  return val === "true";
+}
+registerSchema("guest", "invite", "Invite a guest to a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--email", type: "string", required: true, description: "Email address to invite" },
+  { flag: "--can-edit-tags", type: "boolean", required: false, description: "Allow editing tags" },
+  { flag: "--can-see-time-spent", type: "boolean", required: false, description: "Allow seeing time spent" },
+  { flag: "--can-see-time-estimated", type: "boolean", required: false, description: "Allow seeing time estimates" }
+]);
+registerSchema("guest", "get", "Get a guest in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" }
+]);
+registerSchema("guest", "update", "Update a guest in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--username", type: "string", required: false, description: "New username" },
+  { flag: "--can-edit-tags", type: "boolean", required: false, description: "Allow editing tags" },
+  { flag: "--can-see-time-spent", type: "boolean", required: false, description: "Allow seeing time spent" },
+  { flag: "--can-see-time-estimated", type: "boolean", required: false, description: "Allow seeing time estimates" }
+]);
+registerSchema("guest", "remove", "Remove a guest from a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("guest", "add-to-task", "Add a guest to a task", [
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" },
+  { flag: "--permission", type: "string", required: true, description: "Permission level (read, comment, edit, create)" }
+]);
+registerSchema("guest", "remove-from-task", "Remove a guest from a task", [
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--task-id", type: "string", required: true, description: "Task ID" }
+]);
+registerSchema("guest", "add-to-list", "Add a guest to a list", [
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--list-id", type: "string", required: true, description: "List ID" },
+  { flag: "--permission", type: "string", required: true, description: "Permission level (read, comment, edit, create)" }
+]);
+registerSchema("guest", "remove-from-list", "Remove a guest from a list", [
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--list-id", type: "string", required: true, description: "List ID" }
+]);
+registerSchema("guest", "add-to-folder", "Add a guest to a folder", [
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--folder-id", type: "string", required: true, description: "Folder ID" },
+  { flag: "--permission", type: "string", required: true, description: "Permission level (read, comment, edit, create)" }
+]);
+registerSchema("guest", "remove-from-folder", "Remove a guest from a folder", [
+  { flag: "<guest-id>", type: "string", required: true, description: "Guest ID" },
+  { flag: "--folder-id", type: "string", required: true, description: "Folder ID" }
+]);
+function registerGuestCommands(program, getClient) {
+  const guest = program.command("guest").description("Manage workspace guests");
+  guest.command("invite").description("Invite a guest to a workspace").requiredOption("--email <email>", "Email address to invite").option("--can-edit-tags <bool>", "Allow editing tags").option("--can-see-time-spent <bool>", "Allow seeing time spent").option("--can-see-time-estimated <bool>", "Allow seeing time estimates").action(async (opts) => {
+    const workspaceId = requireWorkspaceId9(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { email: opts.email };
+    const canEditTags = parseBool(opts.canEditTags);
+    if (canEditTags !== void 0) body["can_edit_tags"] = canEditTags;
+    const canSeeTimeSpent = parseBool(opts.canSeeTimeSpent);
+    if (canSeeTimeSpent !== void 0) body["can_see_time_spent"] = canSeeTimeSpent;
+    const canSeeTimeEstimated = parseBool(opts.canSeeTimeEstimated);
+    if (canSeeTimeEstimated !== void 0) body["can_see_time_estimated"] = canSeeTimeEstimated;
+    const data = await client.post(`/team/${workspaceId}/guest`, body);
+    process.stdout.write(`Invited guest ${data.guest?.id ?? opts.email}
+`);
+  });
+  guest.command("get").description("Get a guest in a workspace").argument("<guest-id>", "Guest ID").action(async (guestId) => {
+    const workspaceId = requireWorkspaceId9(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/guest/${guestId}`);
+    formatOutput(data.guest, GUEST_COLUMNS, getOutputOptions(program));
+  });
+  guest.command("update").description("Update a guest in a workspace").argument("<guest-id>", "Guest ID").option("--username <name>", "New username").option("--can-edit-tags <bool>", "Allow editing tags").option("--can-see-time-spent <bool>", "Allow seeing time spent").option("--can-see-time-estimated <bool>", "Allow seeing time estimates").action(async (guestId, opts) => {
+    const workspaceId = requireWorkspaceId9(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = {};
+    if (opts.username !== void 0) body["username"] = opts.username;
+    const canEditTags = parseBool(opts.canEditTags);
+    if (canEditTags !== void 0) body["can_edit_tags"] = canEditTags;
+    const canSeeTimeSpent = parseBool(opts.canSeeTimeSpent);
+    if (canSeeTimeSpent !== void 0) body["can_see_time_spent"] = canSeeTimeSpent;
+    const canSeeTimeEstimated = parseBool(opts.canSeeTimeEstimated);
+    if (canSeeTimeEstimated !== void 0) body["can_see_time_estimated"] = canSeeTimeEstimated;
+    await client.put(`/team/${workspaceId}/guest/${guestId}`, body);
+    process.stdout.write(`Updated guest ${guestId}
+`);
+  });
+  guest.command("remove").description("Remove a guest from a workspace").argument("<guest-id>", "Guest ID").option("--confirm", "Skip confirmation prompt").action(async (guestId, opts) => {
+    const workspaceId = requireWorkspaceId9(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to remove in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Remove guest ${guestId} from workspace?` });
+      if (!yes) {
+        process.stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+    await client.delete(`/team/${workspaceId}/guest/${guestId}`);
+    process.stdout.write(`Removed guest ${guestId}
+`);
+  });
+  guest.command("add-to-task").description("Add a guest to a task").argument("<guest-id>", "Guest ID").requiredOption("--task-id <id>", "Task ID").requiredOption("--permission <level>", "Permission level (read, comment, edit, create)").action(async (guestId, opts) => {
+    const client = getClient();
+    await client.post(`/task/${opts.taskId}/guest/${guestId}`, { permission_level: opts.permission });
+    process.stdout.write(`Added guest ${guestId} to task ${opts.taskId}
+`);
+  });
+  guest.command("remove-from-task").description("Remove a guest from a task").argument("<guest-id>", "Guest ID").requiredOption("--task-id <id>", "Task ID").action(async (guestId, opts) => {
+    const client = getClient();
+    await client.delete(`/task/${opts.taskId}/guest/${guestId}`);
+    process.stdout.write(`Removed guest ${guestId} from task ${opts.taskId}
+`);
+  });
+  guest.command("add-to-list").description("Add a guest to a list").argument("<guest-id>", "Guest ID").requiredOption("--list-id <id>", "List ID").requiredOption("--permission <level>", "Permission level (read, comment, edit, create)").action(async (guestId, opts) => {
+    const client = getClient();
+    await client.post(`/list/${opts.listId}/guest/${guestId}`, { permission_level: opts.permission });
+    process.stdout.write(`Added guest ${guestId} to list ${opts.listId}
+`);
+  });
+  guest.command("remove-from-list").description("Remove a guest from a list").argument("<guest-id>", "Guest ID").requiredOption("--list-id <id>", "List ID").action(async (guestId, opts) => {
+    const client = getClient();
+    await client.delete(`/list/${opts.listId}/guest/${guestId}`);
+    process.stdout.write(`Removed guest ${guestId} from list ${opts.listId}
+`);
+  });
+  guest.command("add-to-folder").description("Add a guest to a folder").argument("<guest-id>", "Guest ID").requiredOption("--folder-id <id>", "Folder ID").requiredOption("--permission <level>", "Permission level (read, comment, edit, create)").action(async (guestId, opts) => {
+    const client = getClient();
+    await client.post(`/folder/${opts.folderId}/guest/${guestId}`, { permission_level: opts.permission });
+    process.stdout.write(`Added guest ${guestId} to folder ${opts.folderId}
+`);
+  });
+  guest.command("remove-from-folder").description("Remove a guest from a folder").argument("<guest-id>", "Guest ID").requiredOption("--folder-id <id>", "Folder ID").action(async (guestId, opts) => {
+    const client = getClient();
+    await client.delete(`/folder/${opts.folderId}/guest/${guestId}`);
+    process.stdout.write(`Removed guest ${guestId} from folder ${opts.folderId}
+`);
+  });
+}
+
+// src/commands/role.ts
+init_config();
+var ROLE_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "name", header: "Name", width: 25 },
+  { key: "custom", header: "Custom", width: 8 },
+  { key: "members_count", header: "Members", width: 10 },
+  { key: "date_created", header: "Created", width: 15 }
+];
+function requireWorkspaceId10(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+registerSchema("role", "list", "List custom roles in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+function registerRoleCommands(program, getClient) {
+  const role = program.command("role").description("Manage custom roles");
+  role.command("list").description("List custom roles").action(async () => {
+    const workspaceId = requireWorkspaceId10(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/customroles`);
+    formatOutput(data.custom_roles, ROLE_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/member.ts
+init_config();
+var MEMBER_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "username", header: "Username", width: 20 },
+  { key: "email", header: "Email", width: 30 },
+  { key: "initials", header: "Initials", width: 10 }
+];
+function resolveMemberParent(opts) {
+  const parents = [];
+  if (opts.taskId) parents.push({ segment: "task", id: opts.taskId });
+  if (opts.listId) parents.push({ segment: "list", id: opts.listId });
+  if (parents.length === 0) {
+    process.stderr.write("Error: Provide one of --task-id or --list-id.\n");
+    process.exit(2);
+    return void 0;
+  }
+  if (parents.length > 1) {
+    process.stderr.write("Error: Provide only one of --task-id or --list-id.\n");
+    process.exit(2);
+    return void 0;
+  }
+  return parents[0];
+}
+registerSchema("member", "list", "List members with access to a task or list", [
+  { flag: "--task-id", type: "string", required: false, description: "Task ID (provide one of --task-id or --list-id)" },
+  { flag: "--list-id", type: "string", required: false, description: "List ID (provide one of --task-id or --list-id)" }
+]);
+registerSchema("member", "find", "Find workspace member by name (fuzzy match)", [
+  { flag: "--name", type: "string", required: true, description: "Member name to search for" },
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID" }
+]);
+registerSchema("member", "resolve", "Resolve member names to user IDs (pipe-friendly)", [
+  { flag: "--names", type: "string", required: true, description: "Comma-separated member names" },
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID" }
+]);
+function getWorkspaceId(program, optsId) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(optsId ?? globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function flattenMember(m) {
+  return {
+    id: m.user["id"],
+    username: m.user["username"],
+    email: m.user["email"],
+    role: m.role
+  };
+}
+function registerMemberCommands(program, getClient) {
+  const member = program.command("member").description("Manage task and list members");
+  member.command("list").description("List members of a task or list").option("--task-id <id>", "Task ID").option("--list-id <id>", "List ID").action(async (opts) => {
+    const parent = resolveMemberParent(opts);
+    if (!parent) return;
+    const client = getClient();
+    const data = await client.get(`/${parent.segment}/${parent.id}/member`);
+    formatOutput(data.members, MEMBER_COLUMNS, getOutputOptions(program));
+  });
+  member.command("find").description("Find workspace member by name (fuzzy match)").requiredOption("--name <name>", "Member name to search for").option("--workspace-id <id>", "Workspace ID").action(async (opts) => {
+    const workspaceId = getWorkspaceId(program, opts.workspaceId);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/member`);
+    const query = opts.name.toLowerCase();
+    const matches = (data.members ?? []).map(flattenMember).filter((m) => {
+      const username = String(m["username"] ?? "").toLowerCase();
+      const email = String(m["email"] ?? "").toLowerCase();
+      return username.includes(query) || email.includes(query);
+    });
+    if (matches.length === 0) {
+      process.stderr.write(`No members found matching "${opts.name}"
+`);
+      process.exit(1);
+      return;
+    }
+    formatOutput(matches, MEMBER_COLUMNS, getOutputOptions(program));
+  });
+  member.command("resolve").description("Resolve member names to user IDs (use --format quiet for IDs only)").requiredOption("--names <names>", "Comma-separated member names").option("--workspace-id <id>", "Workspace ID").action(async (opts) => {
+    const workspaceId = getWorkspaceId(program, opts.workspaceId);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/member`);
+    const names = opts.names.split(",").map((n) => n.trim().toLowerCase()).filter(Boolean);
+    const allMembers = (data.members ?? []).map(flattenMember);
+    const resolved = names.map((query) => {
+      const match = allMembers.find((m) => {
+        const username = String(m["username"] ?? "").toLowerCase();
+        const email = String(m["email"] ?? "").toLowerCase();
+        return username.includes(query) || email.includes(query);
+      });
+      return match ?? { id: "", username: query, email: "(not found)", role: "" };
+    });
+    formatOutput(resolved, MEMBER_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/template.ts
+init_config();
+var TEMPLATE_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "name", header: "Name", width: 40 }
+];
+function requireWorkspaceId11(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+registerSchema("template", "list", "List task templates in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--page", type: "integer", required: false, description: "Page number (starts at 0)" }
+]);
+function registerTemplateCommands(program, getClient) {
+  const template = program.command("template").description("Manage task templates");
+  template.command("list").description("List task templates").option("--page <n>", "Page number (starts at 0)", parseInt).action(async (opts) => {
+    const workspaceId = requireWorkspaceId11(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const params = {};
+    if (opts.page !== void 0) params["page"] = String(opts.page);
+    const data = await client.get(`/team/${workspaceId}/taskTemplate`, params);
+    formatOutput(data.templates, TEMPLATE_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/task-type.ts
+init_config();
+var TASK_TYPE_COLUMNS = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "name", header: "Name", width: 25 },
+  { key: "description", header: "Description", width: 40 }
+];
+function requireWorkspaceId12(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+registerSchema("task-type", "list", "List custom task types in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+function registerTaskTypeCommands(program, getClient) {
+  const taskType = program.command("task-type").description("Manage custom task types");
+  taskType.command("list").description("List custom task types").action(async () => {
+    const workspaceId = requireWorkspaceId12(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/custom_item`);
+    formatOutput(data.custom_items, TASK_TYPE_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/schema-cmd.ts
+var RESOURCE_COLUMNS = [
+  { key: "resource", header: "Resource", width: 20 },
+  { key: "actions", header: "Actions", width: 50 }
+];
+var ACTION_COLUMNS = [
+  { key: "action", header: "Action", width: 15 },
+  { key: "description", header: "Description", width: 50 }
+];
+var FIELD_COLUMNS2 = [
+  { key: "flag", header: "Flag", width: 25 },
+  { key: "type", header: "Type", width: 12 },
+  { key: "required_label", header: "Required", width: 10 },
+  { key: "description", header: "Description", width: 40 }
+];
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function registerSchemaCommands(program) {
+  program.command("schema").description("Discover available resources, actions, and fields").argument("[query]", 'Resource or resource.action (e.g. "task" or "task.create")').action((query) => {
+    const outputOpts = getOutputOptions(program);
+    if (!query) {
+      const resources = getResources();
+      const rows2 = resources.map((r) => {
+        const actions = getActions(r);
+        return {
+          resource: r,
+          actions: actions ? actions.map((a) => a.action).join(", ") : ""
+        };
+      });
+      formatOutput(rows2, RESOURCE_COLUMNS, outputOpts);
+      return;
+    }
+    const dotIndex = query.indexOf(".");
+    if (dotIndex === -1) {
+      const actions = getActions(query);
+      if (!actions) {
+        process.stderr.write(`Error: Unknown resource "${query}". Run: clickup schema
+`);
+        process.exit(2);
+        return;
+      }
+      formatOutput(actions, ACTION_COLUMNS, outputOpts);
+      return;
+    }
+    const resource = query.slice(0, dotIndex);
+    const action = query.slice(dotIndex + 1);
+    const actionDef = getFields(resource, action);
+    if (!actionDef) {
+      process.stderr.write(`Error: Unknown action "${query}". Run: clickup schema ${resource}
+`);
+      process.exit(2);
+      return;
+    }
+    const format = outputOpts.format ?? (process.stdout.isTTY ? "table" : "json");
+    if (format === "json") {
+      const jsonOutput = {
+        resource,
+        action,
+        required: actionDef.fields.filter((f) => f.required).map(({ flag, type, description }) => ({ flag, type, description })),
+        optional: actionDef.fields.filter((f) => !f.required).map(({ flag, type, description }) => ({ flag, type, description }))
+      };
+      process.stdout.write(JSON.stringify(jsonOutput, null, 2) + "\n");
+      return;
+    }
+    process.stdout.write(`${capitalize(resource)} > ${capitalize(action)}
+
+`);
+    const rows = actionDef.fields.map((f) => ({
+      ...f,
+      required_label: f.required ? "yes" : ""
+    }));
+    formatOutput(rows, FIELD_COLUMNS2, outputOpts);
+  });
+}
+
+// src/commands/shared-hierarchy.ts
+init_config();
+var TASK_COLUMNS2 = [
+  { key: "id", header: "ID", width: 12 },
+  { key: "name", header: "Name", width: 30 },
+  { key: "type", header: "Type", width: 8 }
+];
+registerSchema("shared-hierarchy", "get", "Get items shared with the authenticated user", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+function requireWorkspaceId13(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function registerSharedHierarchyCommands(program, getClient) {
+  const sharedHierarchy = program.command("shared-hierarchy").description("Manage shared hierarchy");
+  sharedHierarchy.command("get").description("Get tasks, lists, and folders shared with the authenticated user").action(async () => {
+    const workspaceId = requireWorkspaceId13(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/shared`);
+    const outputOpts = getOutputOptions(program);
+    const format = outputOpts.format ?? (process.stdout.isTTY ? "table" : "json");
+    if (format === "json") {
+      process.stdout.write(JSON.stringify(data.shared, null, 2) + "\n");
+      return;
+    }
+    const rows = [];
+    for (const task of data.shared.tasks ?? []) {
+      rows.push({ id: task.id, name: task.name, type: "task" });
+    }
+    for (const list of data.shared.lists ?? []) {
+      rows.push({ id: list.id, name: list.name, type: "list" });
+    }
+    for (const folder of data.shared.folders ?? []) {
+      rows.push({ id: folder.id, name: folder.name, type: "folder" });
+    }
+    formatOutput(rows, TASK_COLUMNS2, outputOpts);
+  });
+}
+
+// src/commands/doc.ts
+init_config();
+var DOC_COLUMNS = [
+  { key: "id", header: "ID", width: 15 },
+  { key: "name", header: "Name", width: 35 },
+  { key: "date_created", header: "Created", width: 15 },
+  { key: "date_updated", header: "Updated", width: 15 }
+];
+var PAGE_COLUMNS = [
+  { key: "id", header: "ID", width: 15 },
+  { key: "name", header: "Name", width: 35 },
+  { key: "parent_page", header: "Parent", width: 15 },
+  { key: "date_created", header: "Created", width: 15 }
+];
+registerSchema("doc", "list", "List docs in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" }
+]);
+registerSchema("doc", "get", "Get a doc by ID", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--doc-id", type: "string", required: true, description: "Doc ID" }
+]);
+registerSchema("doc", "create", "Create a doc", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--name", type: "string", required: true, description: "Doc name" },
+  { flag: "--parent-id", type: "string", required: false, description: "Parent ID (space, folder, list, or task)" },
+  { flag: "--parent-type", type: "number", required: false, description: "Parent type (4=space, 5=folder, 6=list, 7=task)" },
+  { flag: "--visibility", type: "string", required: false, description: "Visibility (private, workspace)" }
+]);
+registerSchema("doc", "update", "Update a doc", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--doc-id", type: "string", required: true, description: "Doc ID" },
+  { flag: "--name", type: "string", required: false, description: "New doc name" }
+]);
+registerSchema("doc", "delete", "Delete a doc", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--doc-id", type: "string", required: true, description: "Doc ID" },
+  { flag: "--confirm", type: "boolean", required: false, description: "Skip confirmation prompt" }
+]);
+registerSchema("doc", "search", "Search docs in a workspace", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--query", type: "string", required: true, description: "Search query" }
+]);
+registerSchema("doc", "pages", "List pages in a doc", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--doc-id", type: "string", required: true, description: "Doc ID" }
+]);
+registerSchema("doc", "page-get", "Get a page from a doc", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--doc-id", type: "string", required: true, description: "Doc ID" },
+  { flag: "--page-id", type: "string", required: true, description: "Page ID" }
+]);
+registerSchema("doc", "page-create", "Create a page in a doc", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--doc-id", type: "string", required: true, description: "Doc ID" },
+  { flag: "--name", type: "string", required: true, description: "Page name" },
+  { flag: "--content", type: "string", required: false, description: "Page content (markdown)" },
+  { flag: "--parent-page-id", type: "string", required: false, description: "Parent page ID" }
+]);
+registerSchema("doc", "page-update", "Update a page in a doc", [
+  { flag: "--workspace-id", type: "string", required: true, description: "Workspace ID" },
+  { flag: "--doc-id", type: "string", required: true, description: "Doc ID" },
+  { flag: "--page-id", type: "string", required: true, description: "Page ID" },
+  { flag: "--name", type: "string", required: false, description: "New page name" },
+  { flag: "--content", type: "string", required: false, description: "New page content (markdown)" }
+]);
+function requireWorkspaceId14(program) {
+  const globalOpts = program.opts();
+  const workspaceId = resolveWorkspaceId(globalOpts["workspaceId"]);
+  if (!workspaceId) {
+    process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+    process.exit(2);
+    return void 0;
+  }
+  return workspaceId;
+}
+function registerDocCommands(program, getClient) {
+  const doc = program.command("doc").description("Manage docs and pages");
+  doc.command("list").description("List docs in a workspace").action(async () => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/v3/workspaces/${workspaceId}/docs`);
+    formatOutput(data.docs, DOC_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("get").description("Get a doc by ID").requiredOption("--doc-id <id>", "Doc ID").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/v3/workspaces/${workspaceId}/docs/${opts.docId}`);
+    formatOutput(data, DOC_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("create").description("Create a doc").requiredOption("--name <name>", "Doc name").option("--parent-id <id>", "Parent ID").option("--parent-type <type>", "Parent type (4=space, 5=folder, 6=list, 7=task)", parseInt).option("--visibility <visibility>", "Visibility (private, workspace)").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.parentId) {
+      body["parent"] = { id: opts.parentId, type: opts.parentType ?? 4 };
+    }
+    if (opts.visibility) body["visibility"] = opts.visibility;
+    const data = await client.post(`/v3/workspaces/${workspaceId}/docs`, body);
+    formatOutput(data, DOC_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("update").description("Update a doc").requiredOption("--doc-id <id>", "Doc ID").option("--name <name>", "New name").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = {};
+    if (opts.name) body["name"] = opts.name;
+    const data = await client.put(`/v3/workspaces/${workspaceId}/docs/${opts.docId}`, body);
+    formatOutput(data, DOC_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("delete").description("Delete a doc").requiredOption("--doc-id <id>", "Doc ID").option("--confirm", "Skip confirmation prompt").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    if (!opts.confirm) {
+      if (!process.stdin.isTTY) {
+        process.stderr.write("Error: Use --confirm to delete in non-interactive mode.\n");
+        process.exit(2);
+        return;
+      }
+      const { confirm } = await import("@inquirer/prompts");
+      const yes = await confirm({ message: `Delete doc ${opts.docId}?` });
+      if (!yes) {
+        process.stderr.write("Cancelled.\n");
+        return;
+      }
+    }
+    const client = getClient();
+    await client.delete(`/v3/workspaces/${workspaceId}/docs/${opts.docId}`);
+    process.stdout.write(`Doc ${opts.docId} deleted.
+`);
+  });
+  doc.command("search").description("Search docs in a workspace").requiredOption("--query <text>", "Search query").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(`/v3/workspaces/${workspaceId}/docs`, {
+      query: opts.query
+    });
+    formatOutput(data.docs, DOC_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("pages").description("List pages in a doc").requiredOption("--doc-id <id>", "Doc ID").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(
+      `/v3/workspaces/${workspaceId}/docs/${opts.docId}/pages`
+    );
+    formatOutput(data.pages, PAGE_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("page-get").description("Get a page from a doc").requiredOption("--doc-id <id>", "Doc ID").requiredOption("--page-id <id>", "Page ID").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const data = await client.get(
+      `/v3/workspaces/${workspaceId}/docs/${opts.docId}/pages/${opts.pageId}`
+    );
+    formatOutput(data, PAGE_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("page-create").description("Create a page in a doc").requiredOption("--doc-id <id>", "Doc ID").requiredOption("--name <name>", "Page name").option("--content <text>", "Page content (markdown)").option("--parent-page-id <id>", "Parent page ID").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = { name: opts.name };
+    if (opts.content) body["content"] = opts.content;
+    if (opts.parentPageId) body["parent_page"] = opts.parentPageId;
+    const data = await client.post(
+      `/v3/workspaces/${workspaceId}/docs/${opts.docId}/pages`,
+      body
+    );
+    formatOutput(data, PAGE_COLUMNS, getOutputOptions(program));
+  });
+  doc.command("page-update").description("Update a page in a doc").requiredOption("--doc-id <id>", "Doc ID").requiredOption("--page-id <id>", "Page ID").option("--name <name>", "New name").option("--content <text>", "New content (markdown)").action(async (opts) => {
+    const workspaceId = requireWorkspaceId14(program);
+    if (!workspaceId) return;
+    const client = getClient();
+    const body = {};
+    if (opts.name) body["name"] = opts.name;
+    if (opts.content) body["content"] = opts.content;
+    const data = await client.put(
+      `/v3/workspaces/${workspaceId}/docs/${opts.docId}/pages/${opts.pageId}`,
+      body
+    );
+    formatOutput(data, PAGE_COLUMNS, getOutputOptions(program));
+  });
+}
+
+// src/commands/skill-cmd.ts
+import { readdirSync, readFileSync as readFileSync2, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var SKILL_COLUMNS = [
+  { key: "name", header: "Name", width: 28 },
+  { key: "type", header: "Type", width: 10 },
+  { key: "description", header: "Description", width: 55 }
+];
+registerSchema("skill", "list", "List all available skills", []);
+registerSchema("skill", "show", "Show a skill by name", [
+  { flag: "<name>", type: "string", required: true, description: "Skill name" }
+]);
+registerSchema("skill", "path", "Print the file system path to a skill directory", [
+  { flag: "<name>", type: "string", required: true, description: "Skill name" }
+]);
+function findSkillsDir() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const bundledDir = join(thisDir, "..", "skills");
+  if (existsSync(bundledDir)) return bundledDir;
+  const projectDir = join(thisDir, "..", "..", "skills");
+  if (existsSync(projectDir)) return projectDir;
+  return void 0;
+}
+function parseFrontmatter(content) {
+  const fm = {};
+  if (!content.startsWith("---")) {
+    return { frontmatter: fm, body: content };
+  }
+  const endIndex = content.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    return { frontmatter: fm, body: content };
+  }
+  const yamlBlock = content.slice(4, endIndex);
+  for (const line of yamlBlock.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key) fm[key] = value;
+  }
+  const body = content.slice(endIndex + 4).trimStart();
+  return { frontmatter: fm, body };
+}
+function classifySkill(fm) {
+  if (fm["user-invocable"] === "false") return "root";
+  if (fm["disable-model-invocation"] === "true") return "recipe";
+  return "sub-skill";
+}
+function loadSkills(skillsDir) {
+  const skills = [];
+  let entries;
+  try {
+    entries = readdirSync(skillsDir);
+  } catch {
+    return skills;
+  }
+  for (const entry of entries) {
+    const skillFile = join(skillsDir, entry, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    try {
+      const content = readFileSync2(skillFile, "utf-8");
+      const { frontmatter } = parseFrontmatter(content);
+      skills.push({
+        name: frontmatter["name"] || entry,
+        description: (frontmatter["description"] || "").slice(0, 100),
+        type: classifySkill(frontmatter),
+        path: join(skillsDir, entry),
+        frontmatter
+      });
+    } catch {
+    }
+  }
+  return skills.sort((a, b) => {
+    const typeOrder = { root: 0, "sub-skill": 1, recipe: 2 };
+    const aOrder = typeOrder[a.type] ?? 3;
+    const bOrder = typeOrder[b.type] ?? 3;
+    if (aOrder !== bOrder) return aOrder - bOrder;
+    return a.name.localeCompare(b.name);
+  });
+}
+function findSkill(skillsDir, name) {
+  const skillDir = join(skillsDir, name);
+  const skillFile = join(skillDir, "SKILL.md");
+  if (!existsSync(skillFile)) return void 0;
+  try {
+    const content = readFileSync2(skillFile, "utf-8");
+    return { skillDir, content };
+  } catch {
+    return void 0;
+  }
+}
+function registerSkillCommands(program) {
+  const skill = program.command("skill").description("Manage and inspect agent skills");
+  skill.command("list").description("List all available skills").action(() => {
+    const skillsDir = findSkillsDir();
+    if (!skillsDir) {
+      process.stderr.write("Error: Skills directory not found.\n");
+      process.exit(4);
+      return;
+    }
+    const skills = loadSkills(skillsDir);
+    formatOutput(skills, SKILL_COLUMNS, getOutputOptions(program));
+  });
+  skill.command("show").description("Output SKILL.md content to stdout").argument("<name>", "Skill name").action((name) => {
+    const skillsDir = findSkillsDir();
+    if (!skillsDir) {
+      process.stderr.write("Error: Skills directory not found.\n");
+      process.exit(4);
+      return;
+    }
+    const result = findSkill(skillsDir, name);
+    if (!result) {
+      process.stderr.write(`Error: Skill "${name}" not found. Run: clickup skill list
+`);
+      process.exit(4);
+      return;
+    }
+    const outputOpts = getOutputOptions(program);
+    const format = outputOpts.format ?? (process.stdout.isTTY ? "table" : "json");
+    if (format === "json") {
+      const { frontmatter } = parseFrontmatter(result.content);
+      const output = {
+        name: frontmatter["name"] || name,
+        description: frontmatter["description"] || "",
+        type: classifySkill(frontmatter),
+        path: result.skillDir,
+        frontmatter
+      };
+      process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+      return;
+    }
+    process.stdout.write(result.content);
+    if (!result.content.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  });
+  skill.command("path").description("Print file system path to a skill directory").argument("<name>", "Skill name").action((name) => {
+    const skillsDir = findSkillsDir();
+    if (!skillsDir) {
+      process.stderr.write("Error: Skills directory not found.\n");
+      process.exit(4);
+      return;
+    }
+    const result = findSkill(skillsDir, name);
+    if (!result) {
+      process.stderr.write(`Error: Skill "${name}" not found. Run: clickup skill list
+`);
+      process.exit(4);
+      return;
+    }
+    process.stdout.write(result.skillDir + "\n");
+  });
+}
+
+// src/commands/chat.ts
+init_config();
+import { z } from "zod";
+var ChannelSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.string().optional(),
+  member_count: z.number().optional()
+});
+var CHANNEL_COLUMNS = [
+  { key: "id", header: "ID", width: 20 },
+  { key: "name", header: "Name", width: 35 },
+  { key: "type", header: "Type", width: 12 },
+  { key: "member_count", header: "Members", width: 10 }
+];
+registerSchema("chat", "channels", "List chat channels in workspace", [
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID" }
+]);
+registerSchema("chat", "send", "Send a message to a chat channel", [
+  { flag: "--channel-id", type: "string", required: true, description: "Channel ID" },
+  { flag: "--message", type: "string", required: true, description: "Message text" },
+  { flag: "--workspace-id", type: "string", required: false, description: "Workspace ID" }
+]);
+function registerChatCommands(program, getClient) {
+  const chat = program.command("chat").description("Manage chat channels and messages");
+  chat.command("channels").description("List chat channels in workspace").option("--workspace-id <id>", "Workspace ID").action(async (opts) => {
+    const globalOpts = program.opts();
+    const workspaceId = resolveWorkspaceId(opts.workspaceId ?? globalOpts["workspaceId"]);
+    if (!workspaceId) {
+      process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+      process.exit(2);
+      return;
+    }
+    const client = getClient();
+    const data = await client.get(`/team/${workspaceId}/channel`);
+    const rows = Array.isArray(data) ? data : data.channels ?? [];
+    formatOutput(rows, CHANNEL_COLUMNS, getOutputOptions(program));
+  });
+  chat.command("send").description("Send a message to a chat channel").requiredOption("--channel-id <id>", "Channel ID").requiredOption("--message <text>", "Message text").option("--workspace-id <id>", "Workspace ID").action(async (opts) => {
+    const globalOpts = program.opts();
+    const workspaceId = resolveWorkspaceId(opts.workspaceId ?? globalOpts["workspaceId"]);
+    if (!workspaceId) {
+      process.stderr.write("Error: No workspace ID. Use --workspace-id or run: clickup config set workspace_id <id>\n");
+      process.exit(2);
+      return;
+    }
+    const client = getClient();
+    const result = await client.post(
+      `/team/${workspaceId}/channel/${opts.channelId}/message`,
+      { content: opts.message }
+    );
+    formatOutput(result, [
+      { key: "id", header: "Message ID", width: 24 },
+      { key: "content", header: "Content", width: 50 }
+    ], getOutputOptions(program));
+  });
+}
+
+// src/cli.ts
+var VERSION = "0.2.0";
+function createProgram() {
+  const program = new Command();
+  program.name("clickup").description("ClickUp CLI - Manage ClickUp workspaces from the terminal").version(VERSION).option("--token <token>", "API token").option("--workspace-id <id>", "Workspace ID").option("--format <format>", "Output format (table|json|csv|tsv|quiet|id|md)").option("--no-color", "Disable colors").option("--no-header", "Omit column headers").option("--fields <fields>", "Show only specified fields (comma-separated)").option("--filter <filter>", "Client-side filter (key=value)").option("--sort <sort>", "Sort by field (field[:asc|:desc])").option("--limit <n>", "Limit results", parseInt).option("--verbose", "Show request details").option("--debug", "Full debug output").option("--dry-run", "Print what would be sent without executing");
+  return program;
+}
+function createClient(program) {
+  const globalOpts = program.opts();
+  const token = resolveToken(globalOpts["token"]);
+  if (!token) {
+    process.stderr.write("Error: No API token found. Run: clickup auth login\n");
+    process.exit(EXIT_CODES.AUTH_FAILURE);
+  }
+  const clientOpts = { token };
+  if (globalOpts["verbose"]) clientOpts.verbose = true;
+  if (globalOpts["debug"]) clientOpts.debug = true;
+  if (globalOpts["dryRun"]) clientOpts.dryRun = true;
+  return new ClickUpClient(clientOpts);
+}
+function getOutputOptions(program) {
+  const opts = program.opts();
+  const result = {
+    format: resolveOutputFormat(opts["format"]),
+    noHeader: opts["header"] === false,
+    noColor: opts["color"] === false
+  };
+  const fields = opts["fields"];
+  if (fields) result.fields = fields;
+  const sort = opts["sort"];
+  if (sort) result.sort = sort;
+  const limit = opts["limit"];
+  if (limit !== void 0) result.limit = limit;
+  const filter = opts["filter"];
+  if (filter) result.filter = filter;
+  return result;
+}
+function run() {
+  const program = createProgram();
+  registerAuthCommands(program, () => createClient(program));
+  registerConfigCommands(program);
+  registerWorkspaceCommands(program, () => createClient(program));
+  registerSpaceCommands(program, () => createClient(program));
+  registerFolderCommands(program, () => createClient(program));
+  registerListCommands(program, () => createClient(program));
+  registerTaskCommands(program, () => createClient(program));
+  registerChecklistCommands(program, () => createClient(program));
+  registerFieldCommands(program, () => createClient(program));
+  registerTagCommands(program, () => createClient(program));
+  registerDependencyCommands(program, () => createClient(program));
+  registerRelationCommands(program, () => createClient(program));
+  registerAttachmentCommands(program, () => createClient(program));
+  registerCommentCommands(program, () => createClient(program));
+  registerTimeTrackingCommands(program, () => createClient(program));
+  registerGoalCommands(program, () => createClient(program));
+  registerViewCommands(program, () => createClient(program));
+  registerWebhookCommands(program, () => createClient(program));
+  registerUserCommands(program, () => createClient(program));
+  registerGroupCommands(program, () => createClient(program));
+  registerGuestCommands(program, () => createClient(program));
+  registerRoleCommands(program, () => createClient(program));
+  registerMemberCommands(program, () => createClient(program));
+  registerTemplateCommands(program, () => createClient(program));
+  registerTaskTypeCommands(program, () => createClient(program));
+  registerSharedHierarchyCommands(program, () => createClient(program));
+  registerDocCommands(program, () => createClient(program));
+  registerChatCommands(program, () => createClient(program));
+  registerSchemaCommands(program);
+  registerSkillCommands(program);
+  program.parseAsync(process.argv).catch((error) => {
+    if (error instanceof ClickUpError) {
+      process.stderr.write(`Error: ${error.message}
+`);
+      process.exit(mapToExitCode(error));
+    }
+    if (error instanceof Error) {
+      process.stderr.write(`Error: ${error.message}
+`);
+    } else {
+      process.stderr.write(`Error: ${String(error)}
+`);
+    }
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  });
+}
+
+// bin/clickup.ts
+run();