@krodak/clickup-cli 1.19.4 → 1.19.5

package/dist/index.js

@@ -1,55 +1,4 @@
 #!/usr/bin/env node
-import {
-  ClickUpClient,
-  SPRINT_KEYWORDS,
-  TASK_COLUMNS,
-  addProfile,
-  buildTypeMap,
-  colorStatus,
-  deleteFavorite,
-  deleteFilter,
-  fetchMyTasks,
-  findRelatedSpaces,
-  formatAssignConfirmation,
-  formatCommentConfirmation,
-  formatCommentsMarkdown,
-  formatCreateConfirmation,
-  formatDate,
-  formatDateISO,
-  formatDuration,
-  formatGroupedTasksMarkdown,
-  formatListsMarkdown,
-  formatLongDuration,
-  formatMarkdownTable,
-  formatSpacesMarkdown,
-  formatTable,
-  formatTaskDetail,
-  formatTaskDetailMarkdown,
-  formatTimestamp,
-  formatUpdateConfirmation,
-  getConfigPath,
-  getFavorites,
-  getFilters,
-  groupedTaskPicker,
-  isCustomTaskId,
-  isDoneStatus,
-  isTTY,
-  listProfiles,
-  loadConfig,
-  loadRawConfig,
-  openUrl,
-  parseSprintDates,
-  printTasks,
-  removeProfile,
-  runSprintCommand,
-  saveFavorite,
-  saveFilter,
-  setDefaultProfile,
-  shouldOutputJson,
-  showDetailsAndOpen,
-  summarize,
-  writeConfig
-} from "./chunk-HCGKTH6V.js";
 
 // src/index.ts
 import { realpathSync as realpathSync2 } from "fs";
@@ -58,6 +7,1783 @@ import { Command } from "commander";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 
+// src/api.ts
+var BASE_URL = "https://api.clickup.com/api/v2";
+var BASE_URL_V3 = "https://api.clickup.com/api/v3";
+var MAX_PAGES = 100;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function expectRecord(value, context) {
+  if (!isRecord(value)) {
+    throw new Error(`Unexpected API response: expected ${context} object`);
+  }
+  return value;
+}
+function expectRecordField(data, key, context) {
+  return expectRecord(data[key], context);
+}
+function expectNumericField(data, key, context) {
+  const value = Number(data[key]);
+  if (!Number.isInteger(value)) {
+    throw new Error(`Unexpected API response: expected ${context}.${key} to be numeric`);
+  }
+  return value;
+}
+function expectStringField(data, key, context) {
+  const value = data[key];
+  if (typeof value !== "string") {
+    throw new Error(`Unexpected API response: expected ${context}.${key} to be a string`);
+  }
+  return value;
+}
+function expectArrayField(data, key, context) {
+  const value = data[key];
+  if (!Array.isArray(value)) {
+    throw new Error(`Unexpected API response: expected ${context}.${key} to be an array`);
+  }
+  return value;
+}
+function readCollectionField(data, key, context) {
+  if (data[key] === void 0) return [];
+  return expectArrayField(data, key, context);
+}
+function expectBooleanField(data, key, context) {
+  const value = data[key];
+  if (typeof value !== "boolean") {
+    throw new Error(`Unexpected API response: expected ${context}.${key} to be a boolean`);
+  }
+  return value;
+}
+function expectPaginatedCollectionField(data, key, context) {
+  const items = data[key];
+  if (!Array.isArray(items)) {
+    throw new Error(`Unexpected API response: expected ${key} array`);
+  }
+  return {
+    items,
+    lastPage: expectBooleanField(data, "last_page", context)
+  };
+}
+function isCustomTaskId(id) {
+  return /^[A-Z]+-\d+$/i.test(id);
+}
+var ClickUpClient = class {
+  apiToken;
+  teamId;
+  meCache = null;
+  constructor(config) {
+    this.apiToken = config.apiToken;
+    this.teamId = config.teamId;
+  }
+  taskPath(taskId, suffix = "") {
+    const base = `/task/${taskId}${suffix}`;
+    if (isCustomTaskId(taskId) && this.teamId) {
+      const sep = base.includes("?") ? "&" : "?";
+      return `${base}${sep}custom_task_ids=true&team_id=${this.teamId}`;
+    }
+    return base;
+  }
+  customIdQueryParams(taskId) {
+    if (isCustomTaskId(taskId) && this.teamId) {
+      return `?custom_task_ids=true&team_id=${this.teamId}`;
+    }
+    return "";
+  }
+  async _fetch(baseUrl, path, options = {}) {
+    const res = await fetch(`${baseUrl}${path}`, {
+      ...options,
+      signal: AbortSignal.timeout(3e4),
+      headers: {
+        Authorization: this.apiToken,
+        ...options.body ? { "Content-Type": "application/json" } : {},
+        ...options.headers
+      }
+    });
+    if (res.status === 204 || res.headers.get("content-length") === "0") {
+      if (!res.ok) {
+        throw new Error(`ClickUp API error ${res.status}: ${res.statusText}`);
+      }
+      return {};
+    }
+    let parsed;
+    try {
+      parsed = await res.json();
+    } catch {
+      throw new Error(`ClickUp API error ${res.status}: response was not valid JSON`);
+    }
+    const data = expectRecord(parsed, "JSON");
+    if (!res.ok) {
+      const raw = data.err ?? data.error ?? data.ECODE ?? res.statusText;
+      const errMsg = typeof raw === "string" ? raw : JSON.stringify(raw);
+      throw new Error(`ClickUp API error ${res.status}: ${errMsg}`);
+    }
+    return data;
+  }
+  async request(path, options = {}) {
+    return this._fetch(BASE_URL, path, options);
+  }
+  async requestV3(path, options = {}) {
+    return this._fetch(BASE_URL_V3, path, options);
+  }
+  async requestV3Array(path) {
+    const res = await fetch(`${BASE_URL_V3}${path}`, {
+      signal: AbortSignal.timeout(3e4),
+      headers: { Authorization: this.apiToken }
+    });
+    if (res.status === 204 || res.headers.get("content-length") === "0") {
+      if (!res.ok) {
+        throw new Error(`ClickUp API error ${res.status}: ${res.statusText}`);
+      }
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = await res.json();
+    } catch {
+      throw new Error(`ClickUp API error ${res.status}: response was not valid JSON`);
+    }
+    if (!res.ok) {
+      let errMsg = res.statusText;
+      if (isRecord(parsed)) {
+        const raw = parsed.err ?? parsed.error ?? parsed.ECODE;
+        if (typeof raw === "string") errMsg = raw;
+      }
+      throw new Error(`ClickUp API error ${res.status}: ${errMsg}`);
+    }
+    if (!Array.isArray(parsed)) {
+      throw new Error("Unexpected API response: expected JSON array");
+    }
+    return parsed;
+  }
+  async getMe() {
+    if (this.meCache) return this.meCache;
+    const data = await this.request(
+      "/user"
+    );
+    const user = expectRecordField(data, "user", "user");
+    const timezone = typeof user.timezone === "string" && user.timezone ? user.timezone : void 0;
+    this.meCache = {
+      id: expectNumericField(user, "id", "user"),
+      username: expectStringField(user, "username", "user"),
+      ...timezone ? { timezone } : {}
+    };
+    return this.meCache;
+  }
+  async getUserTimezone() {
+    const me = await this.getMe();
+    return me.timezone;
+  }
+  async paginate(buildPath) {
+    const allTasks = [];
+    let page = 0;
+    let lastPage = false;
+    while (!lastPage && page < MAX_PAGES) {
+      const data = await this.request(buildPath(page));
+      const taskPage = expectPaginatedCollectionField(
+        data,
+        "tasks",
+        "task page"
+      );
+      allTasks.push(...taskPage.items);
+      lastPage = taskPage.lastPage;
+      page++;
+    }
+    if (page >= MAX_PAGES && !lastPage) {
+      process.stderr.write(
+        `Warning: reached maximum page limit (${MAX_PAGES}), results may be incomplete
+`
+      );
+    }
+    return allTasks;
+  }
+  async getMyTasks(teamId, filters = {}) {
+    const baseParams = new URLSearchParams({
+      subtasks: String(filters.subtasks ?? true)
+    });
+    if (filters.includeClosed) baseParams.set("include_closed", "true");
+    if (!filters.all) {
+      const me = await this.getMe();
+      baseParams.append("assignees[]", String(me.id));
+    }
+    if (filters.assignees) {
+      for (const id of filters.assignees) baseParams.append("assignees[]", String(id));
+    }
+    for (const s of filters.statuses ?? []) baseParams.append("statuses[]", s);
+    for (const id of filters.listIds ?? []) baseParams.append("list_ids[]", id);
+    for (const id of filters.spaceIds ?? []) baseParams.append("space_ids[]", id);
+    for (const tag of filters.tags ?? []) baseParams.append("tags[]", tag);
+    if (filters.dueDateGt) baseParams.set("due_date_gt", String(filters.dueDateGt));
+    if (filters.dueDateLt) baseParams.set("due_date_lt", String(filters.dueDateLt));
+    if (filters.dateCreatedGt) baseParams.set("date_created_gt", String(filters.dateCreatedGt));
+    if (filters.dateCreatedLt) baseParams.set("date_created_lt", String(filters.dateCreatedLt));
+    if (filters.dateUpdatedGt) baseParams.set("date_updated_gt", String(filters.dateUpdatedGt));
+    if (filters.dateUpdatedLt) baseParams.set("date_updated_lt", String(filters.dateUpdatedLt));
+    if (filters.customFields?.length) {
+      baseParams.set("custom_fields", JSON.stringify(filters.customFields));
+    }
+    return this.paginate((page) => {
+      const params = new URLSearchParams(baseParams);
+      params.set("page", String(page));
+      return `/team/${teamId}/task?${params.toString()}`;
+    });
+  }
+  async updateTask(taskId, options) {
+    return this.request(this.taskPath(taskId), {
+      method: "PUT",
+      body: JSON.stringify(options)
+    });
+  }
+  async postComment(taskId, commentText, notifyAll) {
+    const body = { comment_text: commentText };
+    if (notifyAll) body.notify_all = true;
+    return this.request(this.taskPath(taskId, "/comment"), {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async getTaskComments(taskId) {
+    const data = await this.request(this.taskPath(taskId, "/comment"));
+    return readCollectionField(
+      data,
+      "comments",
+      "task comments"
+    );
+  }
+  async getTasksFromList(listId, params = {}, options = {}) {
+    return this.paginate((page) => {
+      const base = { subtasks: "true", page: String(page), ...params };
+      if (options.includeClosed) base["include_closed"] = "true";
+      const qs = new URLSearchParams(base).toString();
+      return `/list/${listId}/task?${qs}`;
+    });
+  }
+  async getTask(taskId) {
+    return this.request(this.taskPath(taskId, "?include_markdown_description=true"));
+  }
+  async getTimeInStatus(taskId) {
+    return this.request(this.taskPath(taskId, "/time_in_status"));
+  }
+  async createTask(listId, options) {
+    return this.request(`/list/${listId}/task`, {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  async getTeams() {
+    const data = await this.request("/team");
+    return readCollectionField(data, "teams", "teams");
+  }
+  async getSpaceWithStatuses(spaceId) {
+    return this.request(`/space/${spaceId}`);
+  }
+  async getListWithStatuses(listId) {
+    return this.request(`/list/${listId}`);
+  }
+  async createSpace(teamId, name) {
+    return this.request(`/team/${teamId}/space`, {
+      method: "POST",
+      body: JSON.stringify({ name, multiple_assignees: true })
+    });
+  }
+  async getSpaces(teamId) {
+    const data = await this.request(`/team/${teamId}/space?archived=false`);
+    return readCollectionField(data, "spaces", "spaces");
+  }
+  async getCustomTaskTypes(teamId) {
+    const data = await this.request(
+      `/team/${teamId}/custom_item`
+    );
+    return readCollectionField(
+      data,
+      "custom_items",
+      "custom task types"
+    );
+  }
+  async createList(spaceId, name) {
+    return this.request(`/space/${spaceId}/list`, {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+  }
+  async createFolderList(folderId, name) {
+    return this.request(`/folder/${folderId}/list`, {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+  }
+  async updateList(listId, payload) {
+    return this.request(`/list/${listId}`, {
+      method: "PUT",
+      body: JSON.stringify(payload)
+    });
+  }
+  async createFolder(spaceId, name) {
+    return this.request(`/space/${spaceId}/folder`, {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+  }
+  async getLists(spaceId) {
+    const data = await this.request(`/space/${spaceId}/list?archived=false`);
+    return readCollectionField(data, "lists", "space lists");
+  }
+  async getFolders(spaceId) {
+    const data = await this.request(
+      `/space/${spaceId}/folder?archived=false`
+    );
+    return readCollectionField(data, "folders", "space folders");
+  }
+  async getFolderLists(folderId) {
+    const data = await this.request(`/folder/${folderId}/list?archived=false`);
+    return readCollectionField(data, "lists", "folder lists");
+  }
+  async getListViews(listId) {
+    return this.request(`/list/${listId}/view`);
+  }
+  async getSpaceViews(spaceId) {
+    const data = await this.request(`/space/${spaceId}/view`);
+    return readCollectionField(data, "views", "views");
+  }
+  async getFolderViews(folderId) {
+    const data = await this.request(`/folder/${folderId}/view`);
+    return readCollectionField(data, "views", "views");
+  }
+  async getWorkspaceViews(teamId) {
+    const data = await this.request(`/team/${teamId}/view`);
+    return readCollectionField(data, "views", "views");
+  }
+  async getViewTasks(viewId) {
+    return this.paginate((page) => `/view/${viewId}/task?page=${page}`);
+  }
+  async getView(viewId) {
+    const data = await this.request(`/view/${viewId}`);
+    return expectRecordField(data, "view", "view");
+  }
+  async createListView(listId, payload) {
+    const data = await this.request(`/list/${listId}/view`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+    return expectRecordField(data, "view", "view");
+  }
+  async updateView(viewId, payload) {
+    const data = await this.request(`/view/${viewId}`, {
+      method: "PUT",
+      body: JSON.stringify(payload)
+    });
+    return expectRecordField(data, "view", "view");
+  }
+  async deleteView(viewId) {
+    await this.request(`/view/${viewId}`, { method: "DELETE" });
+  }
+  async getListTemplates(teamId) {
+    const data = await this.request(`/team/${teamId}/list_template`);
+    return readCollectionField(
+      data,
+      "templates",
+      "list templates"
+    );
+  }
+  async getFolderTemplates(teamId) {
+    const data = await this.request(
+      `/team/${teamId}/folder_template`
+    );
+    return readCollectionField(
+      data,
+      "templates",
+      "folder templates"
+    );
+  }
+  async createListFromTemplate(containerId, templateId, name, containerType) {
+    return this.request(
+      `/${containerType}/${containerId}/list_template/${templateId}`,
+      { method: "POST", body: JSON.stringify({ name }) }
+    );
+  }
+  async addTaskToList(taskId, listId) {
+    await this.request(`/list/${listId}/task/${taskId}`, { method: "POST" });
+  }
+  async removeTaskFromList(taskId, listId) {
+    await this.request(`/list/${listId}/task/${taskId}`, { method: "DELETE" });
+  }
+  async setCustomFieldValue(taskId, fieldId, value) {
+    await this.request(this.taskPath(taskId, `/field/${fieldId}`), {
+      method: "POST",
+      body: JSON.stringify({ value })
+    });
+  }
+  async removeCustomFieldValue(taskId, fieldId) {
+    await this.request(this.taskPath(taskId, `/field/${fieldId}`), { method: "DELETE" });
+  }
+  async deleteTask(taskId) {
+    await this.request(this.taskPath(taskId), { method: "DELETE" });
+  }
+  async addTagToTask(taskId, tagName) {
+    await this.request(this.taskPath(taskId, `/tag/${encodeURIComponent(tagName)}`), {
+      method: "POST"
+    });
+  }
+  async removeTagFromTask(taskId, tagName) {
+    await this.request(this.taskPath(taskId, `/tag/${encodeURIComponent(tagName)}`), {
+      method: "DELETE"
+    });
+  }
+  async addDependency(taskId, opts) {
+    const body = {};
+    if (opts.dependsOn) body.depends_on = opts.dependsOn;
+    if (opts.dependencyOf) body.dependency_of = opts.dependencyOf;
+    await this.request(this.taskPath(taskId, "/dependency"), {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async deleteDependency(taskId, opts) {
+    const params = new URLSearchParams();
+    if (opts.dependsOn) params.set("depends_on", opts.dependsOn);
+    if (opts.dependencyOf) params.set("dependency_of", opts.dependencyOf);
+    await this.request(this.taskPath(taskId, `/dependency?${params.toString()}`), {
+      method: "DELETE"
+    });
+  }
+  async updateComment(commentId, text, resolved) {
+    const body = { comment_text: text };
+    if (resolved !== void 0) body.resolved = resolved;
+    await this.request(`/comment/${commentId}`, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+  }
+  async deleteComment(commentId) {
+    await this.request(`/comment/${commentId}`, { method: "DELETE" });
+  }
+  async getThreadedComments(commentId) {
+    const data = await this.request(`/comment/${commentId}/reply`);
+    return readCollectionField(
+      data,
+      "comments",
+      "threaded comments"
+    );
+  }
+  async createThreadedComment(commentId, text, notifyAll) {
+    const body = { comment_text: text };
+    if (notifyAll) body.notify_all = true;
+    await this.request(`/comment/${commentId}/reply`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async addTaskLink(taskId, linksTo) {
+    await this.request(this.taskPath(taskId, `/link/${linksTo}`), {
+      method: "POST"
+    });
+  }
+  async deleteTaskLink(taskId, linksTo) {
+    await this.request(this.taskPath(taskId, `/link/${linksTo}`), {
+      method: "DELETE"
+    });
+  }
+  async getListCustomFields(listId) {
+    const data = await this.request(`/list/${listId}/field`);
+    return readCollectionField(
+      data,
+      "fields",
+      "list custom fields"
+    );
+  }
+  async createChecklist(taskId, name) {
+    const data = await this.request(this.taskPath(taskId, "/checklist"), {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+    return expectRecordField(
+      data,
+      "checklist",
+      "checklist"
+    );
+  }
+  async deleteChecklist(checklistId) {
+    await this.request(`/checklist/${checklistId}`, { method: "DELETE" });
+  }
+  async createChecklistItem(checklistId, name) {
+    const data = await this.request(
+      `/checklist/${checklistId}/checklist_item`,
+      { method: "POST", body: JSON.stringify({ name }) }
+    );
+    return expectRecordField(
+      data,
+      "checklist",
+      "checklist"
+    );
+  }
+  async editChecklistItem(checklistId, checklistItemId, updates) {
+    const data = await this.request(
+      `/checklist/${checklistId}/checklist_item/${checklistItemId}`,
+      { method: "PUT", body: JSON.stringify(updates) }
+    );
+    return expectRecordField(
+      data,
+      "checklist",
+      "checklist"
+    );
+  }
+  async deleteChecklistItem(checklistId, checklistItemId) {
+    await this.request(
+      `/checklist/${checklistId}/checklist_item/${checklistItemId}`,
+      { method: "DELETE" }
+    );
+  }
+  async startTimeEntry(teamId, taskId, description) {
+    const body = {
+      tid: taskId,
+      start: Date.now(),
+      duration: -1
+    };
+    if (description) body.description = description;
+    const data = await this.request(
+      `/team/${teamId}/time_entries/start${this.customIdQueryParams(taskId)}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+    return data.data;
+  }
+  async stopTimeEntry(teamId) {
+    const data = await this.request(`/team/${teamId}/time_entries/stop`, {
+      method: "POST"
+    });
+    return data.data;
+  }
+  async getRunningTimeEntry(teamId) {
+    const data = await this.request(
+      `/team/${teamId}/time_entries/current`
+    );
+    return data.data ?? null;
+  }
+  async createTimeEntry(teamId, taskId, duration, opts) {
+    const start = opts?.start ?? Date.now() - duration;
+    const body = {
+      tid: taskId,
+      start,
+      duration
+    };
+    if (opts?.description) body.description = opts.description;
+    const data = await this.request(
+      `/team/${teamId}/time_entries${this.customIdQueryParams(taskId)}`,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      }
+    );
+    return data.data;
+  }
+  async getTimeEntries(teamId, opts) {
+    const params = new URLSearchParams();
+    if (opts?.startDate != null) params.set("start_date", String(opts.startDate));
+    if (opts?.endDate != null) params.set("end_date", String(opts.endDate));
+    if (opts?.spaceId) params.set("space_id", opts.spaceId);
+    if (opts?.listId) params.set("list_id", opts.listId);
+    if (opts?.assigneeId) params.set("assignee", opts.assigneeId);
+    const query = params.toString();
+    const url = `/team/${teamId}/time_entries${query ? `?${query}` : ""}`;
+    const data = await this.request(url);
+    const entries = readCollectionField(
+      data,
+      "data",
+      "time entries"
+    );
+    if (opts?.taskId) {
+      return entries.filter((e) => e.task?.id === opts.taskId);
+    }
+    return entries;
+  }
+  async updateTimeEntry(teamId, timeEntryId, updates) {
+    const data = await this.request(
+      `/team/${teamId}/time_entries/${timeEntryId}`,
+      { method: "PUT", body: JSON.stringify(updates) }
+    );
+    return data.data;
+  }
+  async getSpaceTags(spaceId) {
+    const data = await this.request(`/space/${spaceId}/tag`);
+    return readCollectionField(data, "tags", "space tags");
+  }
+  async createSpaceTag(spaceId, name, fg, bg) {
+    await this.request(`/space/${spaceId}/tag`, {
+      method: "POST",
+      body: JSON.stringify({
+        tag: { name, tag_fg: fg ?? "#000000", tag_bg: bg ?? "#04A9F4" }
+      })
+    });
+  }
+  async deleteSpaceTag(spaceId, tagName) {
+    await this.request(
+      `/space/${spaceId}/tag/${encodeURIComponent(tagName)}`,
+      { method: "DELETE" }
+    );
+  }
+  async getWorkspaceMembers(teamId) {
+    const data = await this.request("/team");
+    const team = readCollectionField(
+      data,
+      "teams",
+      "workspace members"
+    ).find((t) => t.id === teamId);
+    return team?.members?.map((m) => m.user) ?? [];
+  }
+  async deleteTimeEntry(teamId, timeEntryId) {
+    await this.request(`/team/${teamId}/time_entries/${timeEntryId}`, {
+      method: "DELETE"
+    });
+  }
+  async createTaskAttachment(taskId, filePath) {
+    const { readFile } = await import("fs/promises");
+    const { basename: basename2 } = await import("path");
+    const fileBuffer = await readFile(filePath);
+    const fileName = basename2(filePath);
+    const formData = new FormData();
+    formData.append("attachment", new Blob([fileBuffer]), fileName);
+    const res = await fetch(`${BASE_URL}${this.taskPath(taskId, "/attachment")}`, {
+      method: "POST",
+      headers: { Authorization: this.apiToken },
+      body: formData,
+      signal: AbortSignal.timeout(6e4)
+    });
+    if (!res.ok) {
+      let msg;
+      try {
+        const data2 = await res.json();
+        msg = data2.err ?? `HTTP ${res.status}`;
+      } catch {
+        msg = `HTTP ${res.status}`;
+      }
+      throw new Error(`ClickUp API error ${res.status}: ${msg}`);
+    }
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      throw new Error(`ClickUp API error ${res.status}: response was not valid JSON`);
+    }
+    return data;
+  }
+  async getDocs(workspaceId) {
+    const data = await this.requestV3(`/workspaces/${workspaceId}/docs`);
+    return readCollectionField(data, "docs", "docs");
+  }
+  async getDocPage(workspaceId, docId, pageId) {
+    return this.requestV3(
+      `/workspaces/${workspaceId}/docs/${docId}/pages/${pageId}?content_format=text/md`
+    );
+  }
+  async createDoc(workspaceId, title, content, parentId) {
+    const body = { title };
+    if (content) body.content = content;
+    if (parentId) {
+      body.parent_id = parentId;
+      body.parent_type = "doc";
+    }
+    return this.requestV3(`/workspaces/${workspaceId}/docs`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async createDocPage(workspaceId, docId, name, content, parentPageId) {
+    const body = { name, content_format: "text/md" };
+    if (content) body.content = content;
+    if (parentPageId) body.parent_page_id = parentPageId;
+    return this.requestV3(`/workspaces/${workspaceId}/docs/${docId}/pages`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async editDocPage(workspaceId, docId, pageId, updates) {
+    return this.requestV3(`/workspaces/${workspaceId}/docs/${docId}/pages/${pageId}`, {
+      method: "PUT",
+      body: JSON.stringify(updates)
+    });
+  }
+  async getDoc(workspaceId, docId) {
+    return this.requestV3(`/workspaces/${workspaceId}/docs/${docId}`);
+  }
+  async getDocPageListing(workspaceId, docId) {
+    return this.requestV3Array(`/workspaces/${workspaceId}/docs/${docId}/pages`);
+  }
+  async getDocPages(workspaceId, docId) {
+    return this.requestV3Array(
+      `/workspaces/${workspaceId}/docs/${docId}/pages?content_format=text/md`
+    );
+  }
+  async getGoals(teamId) {
+    const data = await this.request(`/team/${teamId}/goal`);
+    return readCollectionField(data, "goals", "goals");
+  }
+  async createGoal(teamId, name, opts) {
+    const body = { name, multiple_owners: true };
+    if (opts?.description) body.description = opts.description;
+    if (opts?.dueDate != null) body.due_date = opts.dueDate;
+    if (opts?.color) body.color = opts.color;
+    const data = await this.request(`/team/${teamId}/goal`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return data.goal;
+  }
+  async updateGoal(goalId, updates) {
+    const data = await this.request(`/goal/${goalId}`, {
+      method: "PUT",
+      body: JSON.stringify(updates)
+    });
+    return data.goal;
+  }
+  async getKeyResults(goalId) {
+    const data = await this.request(`/goal/${goalId}`);
+    return data.goal?.key_results ?? [];
+  }
+  async createKeyResult(goalId, name, type, stepsEnd) {
+    const data = await this.request(`/goal/${goalId}/key_result`, {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        type,
+        steps_start: 0,
+        steps_end: stepsEnd,
+        unit: type === "number" ? "items" : "%"
+      })
+    });
+    return data.key_result;
+  }
+  async updateKeyResult(keyResultId, updates) {
+    const data = await this.request(`/key_result/${keyResultId}`, {
+      method: "PUT",
+      body: JSON.stringify(updates)
+    });
+    return data.key_result;
+  }
+  async deleteGoal(goalId) {
+    await this.request(`/goal/${goalId}`, { method: "DELETE" });
+  }
+  async deleteKeyResult(keyResultId) {
+    await this.request(`/key_result/${keyResultId}`, { method: "DELETE" });
+  }
+  async deleteDoc(workspaceId, docId) {
+    await this.requestV3(`/workspaces/${workspaceId}/docs/${docId}`, {
+      method: "DELETE"
+    });
+  }
+  async deleteDocPage(workspaceId, docId, pageId) {
+    await this.requestV3(
+      `/workspaces/${workspaceId}/docs/${docId}/pages/${pageId}`,
+      { method: "DELETE" }
+    );
+  }
+  async updateSpaceTag(spaceId, tagName, updates) {
+    await this.request(
+      `/space/${spaceId}/tag/${encodeURIComponent(tagName)}`,
+      {
+        method: "PUT",
+        body: JSON.stringify({
+          tag: {
+            name: updates.name,
+            tag_fg: updates.tag_fg ?? "#000000",
+            tag_bg: updates.tag_bg ?? "#04A9F4"
+          }
+        })
+      }
+    );
+  }
+  async getTaskTemplates(teamId) {
+    const data = await this.request(
+      `/team/${teamId}/taskTemplate?page=0`
+    );
+    return readCollectionField(
+      data,
+      "templates",
+      "task templates"
+    );
+  }
+  async createTaskFromTemplate(listId, templateId, name) {
+    return this.request(`/list/${listId}/taskTemplate/${templateId}`, {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+  }
+  async createCustomField(teamId, name, type, opts) {
+    const typeConfig = {};
+    if (opts?.options?.length) {
+      typeConfig.options = opts.options.map((optName, i) => ({
+        name: optName,
+        orderindex: i
+      }));
+    }
+    const body = {
+      name,
+      type,
+      type_config: typeConfig,
+      description: opts?.description ?? "",
+      required: opts?.required ?? false,
+      pinned: false,
+      hide_from_guests: false,
+      required_on_subtasks: false,
+      private: false,
+      permission_level: null,
+      members: [],
+      groups: []
+    };
+    const data = await this.request(
+      `/field?workspace_id=${teamId}`,
+      { method: "POST", body: JSON.stringify(body) }
+    );
+    return data.data;
+  }
+};
+
+// src/config.ts
+import fs from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readConfigString(parsed, key, path, strict) {
+  const value = parsed[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    if (strict) {
+      throw new Error(`Config field ${key} must be a string in ${path}.`);
+    }
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function parseConfigFile(raw, path, strictFields, strictRoot = strictFields) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    if (strictRoot) {
+      throw new Error(`Config file at ${path} contains invalid JSON. Please check the file syntax.`);
+    }
+    return {};
+  }
+  if (!isRecord2(parsed)) {
+    if (strictRoot) {
+      throw new Error(`Config file at ${path} must contain a JSON object.`);
+    }
+    return {};
+  }
+  const apiToken = readConfigString(parsed, "apiToken", path, strictFields);
+  const teamId = readConfigString(parsed, "teamId", path, strictFields);
+  const sprintFolderId = readConfigString(parsed, "sprintFolderId", path, strictFields);
+  return {
+    ...apiToken ? { apiToken } : {},
+    ...teamId ? { teamId } : {},
+    ...sprintFolderId ? { sprintFolderId } : {}
+  };
+}
+function trimConfigValue(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return join(xdg, "cup");
+  return join(homedir(), ".config", "cup");
+}
+function legacyConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return join(xdg, "cu");
+  return join(homedir(), ".config", "cu");
+}
+var migrationChecked = false;
+function migrateFromLegacy() {
+  if (migrationChecked) return;
+  migrationChecked = true;
+  const legacy = legacyConfigDir();
+  const current = configDir();
+  if (fs.existsSync(join(legacy, "config.json")) && !fs.existsSync(join(current, "config.json"))) {
+    fs.mkdirSync(current, { recursive: true, mode: 448 });
+    fs.copyFileSync(join(legacy, "config.json"), join(current, "config.json"));
+  }
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function migrateToMultiProfile(parsed, filePath) {
+  if (typeof parsed.apiToken === "string" && !parsed.profiles) {
+    const profile = {};
+    const token = trimConfigValue(parsed.apiToken);
+    if (token) profile.apiToken = token;
+    const team = typeof parsed.teamId === "string" ? trimConfigValue(parsed.teamId) : void 0;
+    if (team) profile.teamId = team;
+    const sprint = typeof parsed.sprintFolderId === "string" ? trimConfigValue(parsed.sprintFolderId) : void 0;
+    if (sprint) profile.sprintFolderId = sprint;
+    const migrated = {
+      defaultProfile: "default",
+      profiles: { default: profile }
+    };
+    const dir = configDir();
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+    fs.writeFileSync(join(dir, "config.json"), JSON.stringify(migrated, null, 2) + "\n", {
+      encoding: "utf-8",
+      mode: 384
+    });
+    return migrated;
+  }
+  if (isRecord2(parsed.profiles)) {
+    const profiles = {};
+    for (const [name, value] of Object.entries(parsed.profiles)) {
+      if (isRecord2(value)) {
+        const p = {};
+        if (typeof value.apiToken === "string" && value.apiToken.trim())
+          p.apiToken = value.apiToken.trim();
+        if (typeof value.teamId === "string" && value.teamId.trim()) p.teamId = value.teamId.trim();
+        if (typeof value.sprintFolderId === "string" && value.sprintFolderId.trim())
+          p.sprintFolderId = value.sprintFolderId.trim();
+        if (isRecord2(value.filters)) p.filters = value.filters;
+        if (isRecord2(value.favorites)) p.favorites = value.favorites;
+        profiles[name] = p;
+      }
+    }
+    return {
+      defaultProfile: typeof parsed.defaultProfile === "string" ? parsed.defaultProfile : "",
+      profiles
+    };
+  }
+  throw new Error(`Config file at ${filePath} has unrecognized format.`);
+}
+function parseRawConfig(filePath) {
+  const raw = fs.readFileSync(filePath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Config file at ${filePath} contains invalid JSON. Please check the file syntax.`
+    );
+  }
+  if (!isRecord2(parsed)) {
+    throw new Error(`Config file at ${filePath} must contain a JSON object.`);
+  }
+  return { parsed, raw };
+}
+function isOldFormat(parsed) {
+  return typeof parsed.apiToken === "string" && !parsed.profiles;
+}
+function loadConfig(profileName) {
+  migrateFromLegacy();
+  const envToken = process.env.CU_API_TOKEN?.trim();
+  const envTeamId = process.env.CU_TEAM_ID?.trim();
+  if (envToken && envTeamId) {
+    if (!envToken.startsWith("pk_")) {
+      throw new Error("CU_API_TOKEN must start with pk_.");
+    }
+    return { apiToken: envToken, teamId: envTeamId };
+  }
+  const path = configPath();
+  if (!fs.existsSync(path)) {
+    if (envToken || envTeamId) {
+      throw new Error("Both CU_API_TOKEN and CU_TEAM_ID must be set, or run: cup init");
+    }
+    throw new Error("Config missing required field: apiToken.\nSet CU_API_TOKEN or run: cup init");
+  }
+  const { parsed } = parseRawConfig(path);
+  if (isOldFormat(parsed)) {
+    const fileConfig = parseConfigFile(JSON.stringify(parsed), path, true);
+    const apiToken2 = envToken ?? fileConfig.apiToken;
+    if (!apiToken2) {
+      throw new Error("Config missing required field: apiToken.\nSet CU_API_TOKEN or run: cup init");
+    }
+    if (!apiToken2.startsWith("pk_")) {
+      throw new Error("Config apiToken must start with pk_. The configured token does not.");
+    }
+    const teamId2 = envTeamId ?? fileConfig.teamId;
+    if (!teamId2) {
+      throw new Error("Config missing required field: teamId.\nSet CU_TEAM_ID or run: cup init");
+    }
+    migrateToMultiProfile(parsed, path);
+    return {
+      apiToken: apiToken2,
+      teamId: teamId2,
+      ...fileConfig.sprintFolderId ? { sprintFolderId: fileConfig.sprintFolderId } : {}
+    };
+  }
+  const multi = loadMultiProfileConfig();
+  const resolvedProfile = profileName ?? process.env.CU_PROFILE?.trim() ?? multi.defaultProfile;
+  if (!resolvedProfile) {
+    throw new Error("No default profile set. Run: cup profile use <name>");
+  }
+  const profile = multi.profiles[resolvedProfile];
+  if (!profile) {
+    const available = Object.keys(multi.profiles).join(", ");
+    throw new Error(`Profile "${resolvedProfile}" not found. Available: ${available}`);
+  }
+  const apiToken = envToken ?? profile.apiToken?.trim();
+  if (!apiToken) {
+    throw new Error(
+      `Profile "${resolvedProfile}" missing apiToken. Run: cup profile add ${resolvedProfile}`
+    );
+  }
+  if (!apiToken.startsWith("pk_")) {
+    throw new Error("Config apiToken must start with pk_. The configured token does not.");
+  }
+  const teamId = envTeamId ?? profile.teamId?.trim();
+  if (!teamId) {
+    throw new Error(`Profile "${resolvedProfile}" missing teamId.`);
+  }
+  return {
+    apiToken,
+    teamId,
+    ...profile.sprintFolderId ? { sprintFolderId: profile.sprintFolderId } : {}
+  };
+}
+function loadMultiProfileConfig() {
+  migrateFromLegacy();
+  const path = configPath();
+  if (!fs.existsSync(path)) {
+    return { defaultProfile: "", profiles: {} };
+  }
+  let parsed;
+  try {
+    const raw = fs.readFileSync(path, "utf-8");
+    parsed = JSON.parse(raw);
+  } catch {
+    return { defaultProfile: "", profiles: {} };
+  }
+  if (!isRecord2(parsed)) return { defaultProfile: "", profiles: {} };
+  if (isOldFormat(parsed)) {
+    return migrateToMultiProfile(parsed, path);
+  }
+  return migrateToMultiProfile(parsed, path);
+}
+function saveMultiProfileConfig(config) {
+  const dir = configDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  fs.writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function addProfile(name, profile) {
+  const multi = loadMultiProfileConfig();
+  multi.profiles[name] = profile;
+  if (!multi.defaultProfile) multi.defaultProfile = name;
+  saveMultiProfileConfig(multi);
+}
+function removeProfile(name) {
+  const multi = loadMultiProfileConfig();
+  if (!multi.profiles[name]) {
+    throw new Error(`Profile "${name}" not found.`);
+  }
+  const keys = Object.keys(multi.profiles);
+  if (keys.length <= 1) {
+    throw new Error("Cannot remove the last profile.");
+  }
+  delete multi.profiles[name];
+  if (multi.defaultProfile === name) {
+    multi.defaultProfile = Object.keys(multi.profiles)[0] ?? "";
+  }
+  saveMultiProfileConfig(multi);
+}
+function setDefaultProfile(name) {
+  const multi = loadMultiProfileConfig();
+  if (!multi.profiles[name]) {
+    const available = Object.keys(multi.profiles).join(", ");
+    throw new Error(`Profile "${name}" not found. Available: ${available}`);
+  }
+  multi.defaultProfile = name;
+  saveMultiProfileConfig(multi);
+}
+function listProfiles() {
+  const multi = loadMultiProfileConfig();
+  return Object.entries(multi.profiles).map(([name, profile]) => ({
+    name,
+    isDefault: name === multi.defaultProfile,
+    teamId: profile.teamId
+  }));
+}
+function loadRawConfig(profileName) {
+  migrateFromLegacy();
+  const path = configPath();
+  if (!fs.existsSync(path)) return {};
+  let parsed;
+  try {
+    const raw = fs.readFileSync(path, "utf-8");
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!isRecord2(parsed)) {
+    throw new Error(`Config file at ${path} must contain a JSON object.`);
+  }
+  if (isOldFormat(parsed)) {
+    return parseConfigFile(JSON.stringify(parsed), path, false, true);
+  }
+  const multi = migrateToMultiProfile(parsed, path);
+  const name = profileName || multi.defaultProfile || "default";
+  return multi.profiles[name] ?? {};
+}
+function getConfigPath() {
+  migrateFromLegacy();
+  return configPath();
+}
+function getFilters(profileName) {
+  const multi = loadMultiProfileConfig();
+  const name = profileName ?? process.env.CU_PROFILE?.trim() ?? multi.defaultProfile;
+  const profile = name ? multi.profiles[name] ?? {} : {};
+  return profile.filters ?? {};
+}
+function saveFilter(name, entry, profileName) {
+  const multi = loadMultiProfileConfig();
+  const pName = profileName ?? process.env.CU_PROFILE?.trim() ?? multi.defaultProfile ?? "default";
+  const profile = multi.profiles[pName] ?? {};
+  const filters = { ...profile.filters ?? {}, [name]: entry };
+  multi.profiles[pName] = { ...profile, filters };
+  if (!multi.defaultProfile) multi.defaultProfile = pName;
+  saveMultiProfileConfig(multi);
+}
+function deleteFilter(name, profileName) {
+  const multi = loadMultiProfileConfig();
+  const pName = profileName ?? process.env.CU_PROFILE?.trim() ?? multi.defaultProfile ?? "default";
+  const profile = multi.profiles[pName] ?? {};
+  const filters = { ...profile.filters ?? {} };
+  if (!(name in filters)) {
+    throw new Error(`Filter "${name}" not found.`);
+  }
+  delete filters[name];
+  multi.profiles[pName] = { ...profile, filters };
+  saveMultiProfileConfig(multi);
+}
+function getFavorites(profileName) {
+  const multi = loadMultiProfileConfig();
+  const name = profileName ?? process.env.CU_PROFILE?.trim() ?? multi.defaultProfile;
+  const profile = name ? multi.profiles[name] ?? {} : {};
+  return profile.favorites ?? {};
+}
+function saveFavorite(alias, entry, profileName) {
+  const multi = loadMultiProfileConfig();
+  const pName = profileName ?? process.env.CU_PROFILE?.trim() ?? multi.defaultProfile ?? "default";
+  const profile = multi.profiles[pName] ?? {};
+  const favorites = { ...profile.favorites ?? {}, [alias]: entry };
+  multi.profiles[pName] = { ...profile, favorites };
+  if (!multi.defaultProfile) multi.defaultProfile = pName;
+  saveMultiProfileConfig(multi);
+}
+function deleteFavorite(alias, profileName) {
+  const multi = loadMultiProfileConfig();
+  const pName = profileName ?? process.env.CU_PROFILE?.trim() ?? multi.defaultProfile ?? "default";
+  const profile = multi.profiles[pName] ?? {};
+  const favorites = { ...profile.favorites ?? {} };
+  if (!(alias in favorites)) {
+    throw new Error(`Favorite "${alias}" not found.`);
+  }
+  delete favorites[alias];
+  multi.profiles[pName] = { ...profile, favorites };
+  saveMultiProfileConfig(multi);
+}
+function writeConfig(config, profileName) {
+  const multi = loadMultiProfileConfig();
+  const name = profileName || multi.defaultProfile || "default";
+  const apiToken = trimConfigValue(config.apiToken) ?? void 0;
+  const teamId = trimConfigValue(config.teamId) ?? void 0;
+  const sprintFolderId = trimConfigValue(config.sprintFolderId);
+  const normalizedConfig = {
+    ...apiToken ? { apiToken } : {},
+    ...teamId ? { teamId } : {},
+    ...sprintFolderId ? { sprintFolderId } : {}
+  };
+  multi.profiles[name] = {
+    ...multi.profiles[name],
+    ...normalizedConfig
+  };
+  if (!multi.defaultProfile) multi.defaultProfile = name;
+  saveMultiProfileConfig(multi);
+}
+
+// src/date.ts
+function formatDate(ms) {
+  return new Date(Number(ms)).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function formatTimestamp(ms) {
+  return new Date(Number(ms)).toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+function formatDuration(ms) {
+  const totalMinutes = Math.round(Math.abs(ms) / 6e4);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours > 0 && minutes > 0) return `${hours}h ${minutes}m`;
+  if (hours > 0) return `${hours}h`;
+  return `${minutes}m`;
+}
+function formatLongDuration(ms) {
+  const totalMinutes = Math.round(Math.abs(ms) / 6e4);
+  if (totalMinutes === 0) return "< 1m";
+  const days = Math.floor(totalMinutes / 1440);
+  const hours = Math.floor(totalMinutes % 1440 / 60);
+  const minutes = totalMinutes % 60;
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  return parts.join(" ");
+}
+function formatDateISO(ms) {
+  const d = new Date(Number(ms));
+  const year = d.getUTCFullYear();
+  const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/output.ts
+import chalk from "chalk";
+function isTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+function shouldOutputJson(forceJson) {
+  if (forceJson) return true;
+  if (process.env["CU_OUTPUT"] === "json") return true;
+  return false;
+}
+function cell(value, width) {
+  if (value.length > width) return value.slice(0, width - 1) + "\u2026";
+  return value.padEnd(width);
+}
+function computeWidths(rows, columns) {
+  return columns.map((col) => {
+    const headerLen = col.label.length;
+    const maxDataLen = rows.reduce((max, row) => {
+      const val = String(row[col.key] ?? "");
+      return Math.max(max, val.length);
+    }, 0);
+    const natural = Math.max(headerLen, maxDataLen);
+    return col.maxWidth ? Math.min(natural, col.maxWidth) : natural;
+  });
+}
+function formatTable(rows, columns) {
+  const widths = computeWidths(rows, columns);
+  const header = columns.map((c, i) => cell(c.label, widths[i])).join("  ");
+  const divider = chalk.dim("-".repeat(header.replace(/\x1b\[[0-9;]*m/g, "").length));
+  const lines = [chalk.bold(header), divider];
+  for (const row of rows) {
+    lines.push(
+      columns.map((c, i) => {
+        const raw = String(row[c.key] ?? "");
+        const width = widths[i];
+        const truncated = raw.length > width ? raw.slice(0, width - 1) + "\u2026" : raw;
+        const padding = " ".repeat(Math.max(0, width - truncated.length));
+        return c.format ? c.format(truncated, row) + padding : truncated + padding;
+      }).join("  ")
+    );
+  }
+  return lines.join("\n");
+}
+function colorStatus(status) {
+  const lower = status.toLowerCase();
+  if (lower.includes("done") || lower.includes("complete") || lower.includes("closed"))
+    return chalk.green(status);
+  if (lower.includes("progress") || lower.includes("review") || lower.includes("active"))
+    return chalk.yellow(status);
+  if (lower.includes("block") || lower.includes("stuck")) return chalk.red(status);
+  return chalk.dim(status);
+}
+function colorPriority(priority) {
+  const lower = priority.toLowerCase();
+  if (lower === "urgent") return chalk.red(priority);
+  if (lower === "high") return chalk.yellow(priority);
+  if (lower === "normal") return priority;
+  if (lower === "low") return chalk.dim(priority);
+  return priority;
+}
+function colorDueDate(dateStr, rawTimestamp) {
+  if (!dateStr) return dateStr;
+  if (rawTimestamp) {
+    const ts = Number(rawTimestamp);
+    if (Number.isFinite(ts) && ts < Date.now()) return chalk.red(dateStr);
+  }
+  return dateStr;
+}
+var TASK_COLUMNS = [
+  { key: "id", label: "ID" },
+  { key: "name", label: "NAME", maxWidth: 60 },
+  { key: "status", label: "STATUS", maxWidth: 20, format: (v) => colorStatus(v) },
+  { key: "priority", label: "PRIORITY", maxWidth: 10, format: (v) => colorPriority(v) },
+  {
+    key: "due_date",
+    label: "DUE",
+    maxWidth: 15,
+    format: (v, row) => v ? colorDueDate(v, row.dueRaw) : ""
+  },
+  { key: "list", label: "LIST" }
+];
+
+// src/markdown.ts
+function escapeCell(value) {
+  return value.replace(/\|/g, "\\|");
+}
+function formatMarkdownTable(rows, columns) {
+  const header = "| " + columns.map((c) => c.label).join(" | ") + " |";
+  const divider = "| " + columns.map(() => "---").join(" | ") + " |";
+  const lines = [header, divider];
+  for (const row of rows) {
+    const cells = columns.map((c) => escapeCell(String(row[c.key] ?? "")));
+    lines.push("| " + cells.join(" | ") + " |");
+  }
+  return lines.join("\n");
+}
+var TASK_MD_COLUMNS = [
+  { key: "id", label: "ID" },
+  { key: "name", label: "Name" },
+  { key: "status", label: "Status" },
+  { key: "priority", label: "Priority" },
+  { key: "due_date", label: "Due" },
+  { key: "list", label: "List" }
+];
+function formatTasksMarkdown(tasks) {
+  if (tasks.length === 0) return "No tasks found.";
+  return formatMarkdownTable(tasks, TASK_MD_COLUMNS);
+}
+function formatCommentsMarkdown(comments) {
+  if (comments.length === 0) return "No comments found.";
+  return comments.map((c) => `**${c.user}** (${formatDateISO(c.date)})
+
+${c.text}`).join("\n\n---\n\n");
+}
+var LIST_MD_COLUMNS = [
+  { key: "id", label: "ID" },
+  { key: "name", label: "Name" },
+  { key: "folder", label: "Folder" }
+];
+function formatListsMarkdown(lists) {
+  if (lists.length === 0) return "No lists found.";
+  return formatMarkdownTable(lists, LIST_MD_COLUMNS);
+}
+var SPACE_MD_COLUMNS = [
+  { key: "id", label: "ID" },
+  { key: "name", label: "Name" }
+];
+function formatSpacesMarkdown(spaces) {
+  if (spaces.length === 0) return "No spaces found.";
+  return formatMarkdownTable(spaces, SPACE_MD_COLUMNS);
+}
+function formatGroupedTasksMarkdown(groups) {
+  const sections = groups.filter((g) => g.tasks.length > 0).map((g) => `## ${g.label}
+
+${formatMarkdownTable(g.tasks, TASK_MD_COLUMNS)}`);
+  if (sections.length === 0) return "No tasks found.";
+  return sections.join("\n\n");
+}
+function formatTaskDetailMarkdown(task) {
+  const lines = [`# ${task.name}`, ""];
+  const isInitiative = (task.custom_item_id ?? 0) !== 0;
+  const fields = [
+    ["ID", task.id],
+    ["Status", task.status.status],
+    ["Type", isInitiative ? "initiative" : "task"],
+    ["List", task.list.name],
+    ["URL", task.url],
+    [
+      "Assignees",
+      task.assignees.length > 0 ? task.assignees.map((a) => a.username).join(", ") : void 0
+    ],
+    ["Priority", task.priority?.priority],
+    ["Parent", task.parent ?? void 0],
+    ["Start Date", task.start_date ? formatDateISO(task.start_date) : void 0],
+    ["Due Date", task.due_date ? formatDateISO(task.due_date) : void 0],
+    [
+      "Time Estimate",
+      task.time_estimate != null && task.time_estimate > 0 ? formatDuration(task.time_estimate) : void 0
+    ],
+    [
+      "Time Spent",
+      task.time_spent != null && task.time_spent > 0 ? formatDuration(task.time_spent) : void 0
+    ],
+    ["Tags", task.tags && task.tags.length > 0 ? task.tags.map((t) => t.name).join(", ") : void 0],
+    [
+      "Lists",
+      task.locations && task.locations.length > 0 ? task.locations.map((l) => l.name).join(", ") : void 0
+    ],
+    ["Created", task.date_created ? formatDateISO(task.date_created) : void 0],
+    ["Updated", task.date_updated ? formatDateISO(task.date_updated) : void 0]
+  ];
+  for (const [label, value] of fields) {
+    if (value != null && value !== "") {
+      lines.push(`**${label}:** ${value}`);
+    }
+  }
+  const descriptionContent = task.markdown_content ?? task.description;
+  if (descriptionContent) {
+    lines.push("", "## Description", "", descriptionContent);
+  }
+  if (task.checklists?.length) {
+    lines.push("", "## Checklists", "");
+    for (const cl of task.checklists) {
+      const resolved = cl.items.filter((i) => i.resolved).length;
+      lines.push(`### ${cl.name} (${resolved}/${cl.items.length})`, "");
+      for (const item of cl.items) {
+        lines.push(`- [${item.resolved ? "x" : " "}] ${item.name}`);
+      }
+      lines.push("");
+    }
+  }
+  if (task.attachments?.length) {
+    lines.push("", "## Attachments", "");
+    for (const att of task.attachments) {
+      lines.push(`- [${att.title}](${att.url})`);
+    }
+  }
+  if (task.dependencies?.length) {
+    lines.push("", "## Dependencies", "");
+    for (const dep of task.dependencies) {
+      const direction = dep.depends_on === task.id ? "blocks" : "depends on";
+      const otherId = dep.depends_on === task.id ? dep.task_id : dep.depends_on;
+      lines.push(`- ${direction} ${otherId}`);
+    }
+  }
+  if (task.linked_tasks?.length) {
+    lines.push("", "## Linked Tasks", "");
+    for (const lt of task.linked_tasks) {
+      lines.push(`- ${lt.task_id}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatUpdateConfirmation(id, name) {
+  return `Updated task ${id}: "${name}"`;
+}
+function formatCreateConfirmation(id, name, url) {
+  return `Created task ${id}: "${name}" - ${url}`;
+}
+function formatCommentConfirmation(id) {
+  return `Comment posted (id: ${id})`;
+}
+function formatAssignConfirmation(taskId, opts) {
+  const parts = [];
+  if (opts.to) parts.push(`Assigned ${opts.to} to ${taskId}`);
+  if (opts.remove) parts.push(`Removed ${opts.remove} from ${taskId}`);
+  return parts.join("; ");
+}
+
+// src/interactive.ts
+import { execFileSync } from "child_process";
+import { checkbox, confirm, Separator } from "@inquirer/prompts";
+import chalk2 from "chalk";
+function openUrl(url) {
+  switch (process.platform) {
+    case "darwin":
+      execFileSync("open", [url]);
+      break;
+    case "linux":
+      execFileSync("xdg-open", [url]);
+      break;
+    case "win32":
+      execFileSync("cmd", ["/c", "start", "", url]);
+      break;
+    default:
+      process.stderr.write(`Cannot open browser on ${process.platform}. Visit: ${url}
+`);
+  }
+}
+function descriptionPreview(text, maxLines = 3) {
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
+  const preview = lines.slice(0, maxLines);
+  const result = preview.map((l) => `  ${chalk2.dim(l.length > 100 ? l.slice(0, 99) + "\u2026" : l)}`).join("\n");
+  if (lines.length > maxLines)
+    return result + `
+  ${chalk2.dim(`... (${lines.length - maxLines} more lines)`)}`;
+  return result;
+}
+function stringifyFieldValue(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+function formatCustomFieldValue(field) {
+  if (field.value === null || field.value === void 0) return null;
+  const options = field.type_config?.options;
+  switch (field.type) {
+    case "drop_down": {
+      if (!options) return stringifyFieldValue(field.value);
+      const match = options.find((o) => o.id === Number(field.value));
+      return match?.name ?? stringifyFieldValue(field.value);
+    }
+    case "labels": {
+      if (!Array.isArray(field.value) || !options) return stringifyFieldValue(field.value);
+      const names = field.value.map((id) => options.find((o) => o.id === id)?.name).filter((n) => n !== void 0);
+      return names.length > 0 ? names.join(", ") : null;
+    }
+    case "date": {
+      const ts = Number(field.value);
+      if (!Number.isFinite(ts)) return stringifyFieldValue(field.value);
+      return formatDate(String(ts));
+    }
+    case "checkbox":
+      return field.value === true || field.value === "true" ? "Yes" : "No";
+    default:
+      return stringifyFieldValue(field.value);
+  }
+}
+function formatTaskDetail(task) {
+  const lines = [];
+  const isInitiative = (task.custom_item_id ?? 0) !== 0;
+  const typeLabel = isInitiative ? "initiative" : "task";
+  lines.push(chalk2.bold.underline(task.name));
+  lines.push("");
+  const fields = [
+    ["ID", task.id],
+    ["Status", task.status?.status ? colorStatus(task.status.status) : void 0],
+    ["Type", typeLabel],
+    ["List", task.list?.name],
+    [
+      "Assignees",
+      task.assignees?.length ? task.assignees.map((a) => a.username).join(", ") : void 0
+    ],
+    ["Priority", task.priority?.priority ? colorPriority(task.priority.priority) : void 0],
+    ["Start", task.start_date ? formatDate(task.start_date) : void 0],
+    ["Due", task.due_date ? colorDueDate(formatDate(task.due_date), task.due_date) : void 0],
+    ["Estimate", task.time_estimate ? formatDuration(task.time_estimate) : void 0],
+    ["Tracked", task.time_spent ? formatDuration(task.time_spent) : void 0],
+    ["Tags", task.tags?.length ? task.tags.map((t) => t.name).join(", ") : void 0],
+    ["Lists", task.locations?.length ? task.locations.map((l) => l.name).join(", ") : void 0],
+    ["Parent", task.parent || void 0],
+    ["URL", task.url]
+  ];
+  const maxLabel = Math.max(...fields.filter(([, v]) => v).map(([k]) => k.length));
+  for (const [label, value] of fields) {
+    if (!value) continue;
+    lines.push(`  ${chalk2.bold(label.padEnd(maxLabel + 1))} ${value}`);
+  }
+  if (task.custom_fields?.length) {
+    const formatted = task.custom_fields.map((f) => [f.name, formatCustomFieldValue(f)]).filter((pair) => pair[1] !== null);
+    if (formatted.length > 0) {
+      lines.push("");
+      lines.push(chalk2.bold("Custom Fields"));
+      for (const [name, value] of formatted) {
+        lines.push(`  ${chalk2.bold(name)}  ${value}`);
+      }
+    }
+  }
+  if (task.checklists?.length) {
+    lines.push("");
+    lines.push(chalk2.bold("Checklists"));
+    for (const cl of task.checklists) {
+      const resolved = cl.items.filter((i) => i.resolved).length;
+      lines.push(`  ${chalk2.bold(cl.name)} (${resolved}/${cl.items.length})`);
+      for (const item of cl.items) {
+        const check = item.resolved ? chalk2.green("[x]") : chalk2.dim("[ ]");
+        lines.push(`    ${check} ${item.name}`);
+      }
+    }
+  }
+  if (task.attachments?.length) {
+    lines.push("");
+    lines.push(chalk2.bold("Attachments"));
+    for (const att of task.attachments) {
+      lines.push(`  ${att.title} ${chalk2.dim(att.url)}`);
+    }
+  }
+  if (task.dependencies?.length) {
+    lines.push("");
+    lines.push(chalk2.bold("Dependencies"));
+    for (const dep of task.dependencies) {
+      const direction = dep.depends_on === task.id ? "blocks" : "depends on";
+      const otherId = dep.depends_on === task.id ? dep.task_id : dep.depends_on;
+      lines.push(`  ${direction} ${chalk2.dim(otherId)}`);
+    }
+  }
+  if (task.linked_tasks?.length) {
+    lines.push("");
+    lines.push(chalk2.bold("Linked Tasks"));
+    for (const lt of task.linked_tasks) {
+      lines.push(`  ${chalk2.dim(lt.task_id)}`);
+    }
+  }
+  if (task.text_content?.trim()) {
+    lines.push("");
+    lines.push(descriptionPreview(task.text_content));
+  }
+  return lines.join("\n");
+}
+function formatChoiceName(task) {
+  const id = task.id.padEnd(12);
+  const name = task.name.length > 50 ? task.name.slice(0, 49) + "\u2026" : task.name.padEnd(50);
+  const status = colorStatus(task.status);
+  const priority = task.priority !== "none" ? colorPriority(task.priority) : "";
+  return `${id}  ${name}  ${status}${priority ? "  " + priority : ""}`;
+}
+async function interactiveTaskPicker(tasks) {
+  if (tasks.length === 0) return [];
+  const selected = await checkbox({
+    message: `${tasks.length} task(s) found. Select to view details / open in browser:`,
+    choices: tasks.map((t) => ({
+      name: formatChoiceName(t),
+      value: t.id
+    })),
+    pageSize: 20
+  });
+  return tasks.filter((t) => selected.includes(t.id));
+}
+async function groupedTaskPicker(groups) {
+  const allTasks = groups.flatMap((g) => g.tasks);
+  const totalCount = allTasks.length;
+  if (totalCount === 0) return [];
+  const choices = [];
+  for (const group of groups) {
+    if (group.tasks.length === 0) continue;
+    choices.push(new Separator(chalk2.bold(`${group.label} (${group.tasks.length})`)));
+    for (const task of group.tasks) {
+      choices.push({ name: formatChoiceName(task), value: task.id });
+    }
+  }
+  const selected = await checkbox({
+    message: `${totalCount} task(s) found. Select to view details / open in browser:`,
+    choices,
+    pageSize: 20
+  });
+  return allTasks.filter((t) => selected.includes(t.id));
+}
+async function showDetailsAndOpen(tasks, fetchTask) {
+  if (tasks.length === 0) return;
+  const separator = chalk2.dim("\u2500".repeat(60));
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    if (i > 0) {
+      console.log("");
+      console.log(separator);
+    }
+    console.log("");
+    if (fetchTask) {
+      const full = await fetchTask(task.id);
+      console.log(formatTaskDetail(full));
+    } else {
+      const fallback = {
+        id: task.id,
+        name: task.name,
+        status: { status: task.status, color: "" },
+        custom_item_id: task.task_type === "initiative" ? 1 : 0,
+        assignees: [],
+        url: task.url,
+        list: { id: "", name: task.list },
+        parent: task.parent
+      };
+      console.log(formatTaskDetail(fallback));
+    }
+  }
+  const urls = tasks.map((t) => t.url);
+  console.log("");
+  const shouldOpen = await confirm({
+    message: `Open ${urls.length} task(s) in browser?`,
+    default: true
+  });
+  if (shouldOpen) {
+    for (const url of urls) {
+      openUrl(url);
+    }
+  }
+}
+
+// src/commands/tasks.ts
+var DONE_PATTERNS = ["done", "complete", "closed"];
+function isDoneStatus(status) {
+  const lower = status.toLowerCase();
+  return DONE_PATTERNS.some((p) => lower.includes(p));
+}
+function formatDueDate(ms) {
+  if (!ms) return "";
+  return formatDate(ms);
+}
+function resolveTaskType(task, typeMap) {
+  const id = task.custom_item_id ?? 0;
+  if (id === 0) return "task";
+  return typeMap.get(id) ?? `type_${id}`;
+}
+function summarize(task, typeMap) {
+  return {
+    id: task.id,
+    name: task.name,
+    status: task.status.status,
+    task_type: resolveTaskType(task, typeMap ?? /* @__PURE__ */ new Map()),
+    priority: task.priority?.priority ?? "none",
+    due_date: formatDueDate(task.due_date),
+    ...task.due_date ? { dueRaw: task.due_date } : {},
+    list: task.list.name,
+    url: task.url,
+    ...task.parent ? { parent: task.parent } : {}
+  };
+}
+function buildTypeMap(types) {
+  const map = /* @__PURE__ */ new Map();
+  for (const t of types) {
+    map.set(t.id, t.name);
+  }
+  return map;
+}
+function resolveTypeFilter(typeFilter, typeMap) {
+  if (typeFilter === "task") return 0;
+  const asNum = Number(typeFilter);
+  if (Number.isFinite(asNum)) return asNum;
+  const lower = typeFilter.toLowerCase();
+  for (const [id, name] of typeMap) {
+    if (name.toLowerCase() === lower) return id;
+  }
+  const available = ["task", ...Array.from(typeMap.values())].join(", ");
+  throw new Error(`Unknown task type "${typeFilter}". Available types: ${available}`);
+}
+async function fetchMyTasks(config, opts = {}) {
+  const client = new ClickUpClient(config);
+  const { typeFilter, name, ...apiFilters } = opts;
+  const [allTasks, customTypes] = await Promise.all([
+    client.getMyTasks(config.teamId, apiFilters),
+    client.getCustomTaskTypes(config.teamId)
+  ]);
+  const typeMap = buildTypeMap(customTypes);
+  let filtered = allTasks;
+  if (typeFilter) {
+    const targetId = resolveTypeFilter(typeFilter, typeMap);
+    filtered = allTasks.filter((t) => (t.custom_item_id ?? 0) === targetId);
+  }
+  if (name) {
+    const query = name.toLowerCase();
+    filtered = filtered.filter((t) => t.name.toLowerCase().includes(query));
+  }
+  return filtered.map((t) => summarize(t, typeMap));
+}
+async function printTasks(tasks, forceJson, config) {
+  if (shouldOutputJson(forceJson)) {
+    console.log(JSON.stringify(tasks, null, 2));
+    return;
+  }
+  if (!isTTY()) {
+    console.log(formatTasksMarkdown(tasks));
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log("No tasks found.");
+    return;
+  }
+  const fetchTask = config ? (() => {
+    const client = new ClickUpClient(config);
+    return (id) => client.getTask(id);
+  })() : void 0;
+  const selected = await interactiveTaskPicker(tasks);
+  await showDetailsAndOpen(selected, fetchTask);
+}
+
 // src/status.ts
 function matchStatus(input, statuses) {
   if (!input) return null;
@@ -286,13 +2012,13 @@ async function getTask(config, taskId) {
 }
 
 // src/commands/init.ts
-import { password, select, confirm } from "@inquirer/prompts";
-import fs from "fs";
+import { password, select, confirm as confirm2 } from "@inquirer/prompts";
+import fs2 from "fs";
 async function runInitCommand() {
-  const configPath2 = getConfigPath();
-  if (fs.existsSync(configPath2)) {
-    const overwrite = await confirm({
-      message: `Config already exists at ${configPath2}. Overwrite?`,
+  const configPath3 = getConfigPath();
+  if (fs2.existsSync(configPath3)) {
+    const overwrite = await confirm2({
+      message: `Config already exists at ${configPath3}. Overwrite?`,
       default: false
     });
     if (!overwrite) {
@@ -330,19 +2056,240 @@ async function runInitCommand() {
     });
   }
   writeConfig({ apiToken, teamId });
-  process.stdout.write(`Config written to ${configPath2}
+  process.stdout.write(`Config written to ${configPath3}
+`);
+}
+
+// src/commands/sprint.ts
+import { select as select2 } from "@inquirer/prompts";
+var SPRINT_KEYWORDS = ["sprint", "iteration", "cycle", "scrum"];
+function parseUSDateRange(name) {
+  const m = name.match(/\((\d{1,2})\/(\d{1,2})\s*[-–]\s*(\d{1,2})\/(\d{1,2})\)/);
+  if (!m) return null;
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const start = new Date(year, Number(m[1]) - 1, Number(m[2]));
+  const end = new Date(year, Number(m[3]) - 1, Number(m[4]), 23, 59, 59);
+  if (end < start) end.setFullYear(end.getFullYear() + 1);
+  return { start, end };
+}
+function parseISODateRange(name) {
+  const m = name.match(/\((\d{4}-\d{2}-\d{2})\s*[-–]\s*(\d{4}-\d{2}-\d{2})\)/);
+  if (!m) return null;
+  const [sy, sm, sd] = m[1].split("-").map(Number);
+  const [ey, em, ed] = m[2].split("-").map(Number);
+  const start = new Date(sy, sm - 1, sd);
+  const end = new Date(ey, em - 1, ed, 23, 59, 59);
+  return { start, end };
+}
+function parseMonthDayRange(name) {
+  const months = {
+    jan: 0,
+    feb: 1,
+    mar: 2,
+    apr: 3,
+    may: 4,
+    jun: 5,
+    jul: 6,
+    aug: 7,
+    sep: 8,
+    oct: 9,
+    nov: 10,
+    dec: 11
+  };
+  const m = name.match(/\(([A-Za-z]{3})\s+(\d{1,2})\s*[-–]\s*([A-Za-z]{3})\s+(\d{1,2})\)/);
+  if (!m) return null;
+  const sm = months[m[1].toLowerCase()];
+  const em = months[m[3].toLowerCase()];
+  if (sm === void 0 || em === void 0) return null;
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const start = new Date(year, sm, Number(m[2]));
+  const end = new Date(year, em, Number(m[4]), 23, 59, 59);
+  if (end < start) end.setFullYear(end.getFullYear() + 1);
+  return { start, end };
+}
+function parseEuropeanDateRange(name) {
+  const m = name.match(/\((\d{1,2})\.(\d{1,2})\s*[-–]\s*(\d{1,2})\.(\d{1,2})\)/);
+  if (!m) return null;
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const start = new Date(year, Number(m[2]) - 1, Number(m[1]));
+  const end = new Date(year, Number(m[4]) - 1, Number(m[3]), 23, 59, 59);
+  if (end < start) end.setFullYear(end.getFullYear() + 1);
+  return { start, end };
+}
+function parseSprintDates(name) {
+  return parseUSDateRange(name) ?? parseISODateRange(name) ?? parseMonthDayRange(name) ?? parseEuropeanDateRange(name);
+}
+function findActiveSprintList(lists, today = /* @__PURE__ */ new Date()) {
+  if (lists.length === 0) return null;
+  for (const list of lists) {
+    const dates = parseSprintDates(list.name);
+    if (dates && today >= dates.start && today <= dates.end) return list;
+  }
+  for (const list of lists) {
+    if (list.start_date && list.due_date) {
+      const start = new Date(Number(list.start_date));
+      const end = new Date(Number(list.due_date));
+      if (today >= start && today <= end) return list;
+    }
+  }
+  return lists[lists.length - 1] ?? null;
+}
+var NOISE_WORDS = /* @__PURE__ */ new Set(["product", "team", "the", "and", "for", "test"]);
+function extractSpaceKeywords(spaceName) {
+  return spaceName.replace(/[^a-zA-Z0-9\s]/g, "").split(/\s+/).map((w) => w.toLowerCase()).filter((w) => w.length >= 3 && !NOISE_WORDS.has(w));
+}
+function findRelatedSpaces(mySpaceIds, allSpaces) {
+  const mySpaces = allSpaces.filter((s) => mySpaceIds.has(s.id));
+  const keywords = mySpaces.flatMap((s) => extractSpaceKeywords(s.name));
+  if (keywords.length === 0) return allSpaces;
+  return allSpaces.filter(
+    (s) => mySpaceIds.has(s.id) || keywords.some((kw) => s.name.toLowerCase().includes(kw))
+  );
+}
+function resolveSprintFolderId(config, opts) {
+  const folderId = opts?.folder ?? config.sprintFolderId;
+  if (folderId) return folderId;
+  const favorites = getFavorites();
+  const favoriteFolderIds = Object.values(favorites).filter((f) => f.type === "sprint-folder").map((f) => f.id);
+  return favoriteFolderIds[0];
+}
+async function resolveActiveSprintListId(config, opts) {
+  const client = new ClickUpClient(config);
+  const folderId = resolveSprintFolderId(config, opts);
+  let sprintLists;
+  if (folderId) {
+    sprintLists = await client.getFolderLists(folderId);
+  } else {
+    const [myTasks, allSpaces] = await Promise.all([
+      client.getMyTasks(config.teamId),
+      client.getSpaces(config.teamId)
+    ]);
+    let spaces;
+    if (opts?.space) {
+      spaces = allSpaces.filter(
+        (s) => s.name.toLowerCase().includes(opts.space.toLowerCase()) || s.id === opts.space
+      );
+      if (spaces.length === 0) {
+        throw new Error(`No space matching "${opts.space}" found.`);
+      }
+    } else {
+      const mySpaceIds = new Set(
+        myTasks.map((t) => t.space?.id).filter((id) => Boolean(id))
+      );
+      spaces = findRelatedSpaces(mySpaceIds, allSpaces);
+    }
+    const foldersBySpace = await Promise.all(spaces.map((space) => client.getFolders(space.id)));
+    const sprintFolders = foldersBySpace.flat().filter((f) => {
+      const lower = f.name.toLowerCase();
+      return SPRINT_KEYWORDS.some((kw) => lower.includes(kw));
+    });
+    const listsByFolder = await Promise.all(
+      sprintFolders.map((folder) => client.getFolderLists(folder.id))
+    );
+    sprintLists = listsByFolder.flat();
+  }
+  const activeList = findActiveSprintList(sprintLists);
+  if (!activeList) {
+    throw new Error(
+      'No active sprint list found. Ensure sprint folders contain "sprint", "iteration", "cycle", or "scrum" in their name.'
+    );
+  }
+  return activeList.id;
+}
+async function runSprintCommand(config, opts) {
+  const client = new ClickUpClient(config);
+  process.stderr.write("Detecting active sprint...\n");
+  const folderId = resolveSprintFolderId(config, opts);
+  const [myTasks, allSpaces, customTypes] = await Promise.all([
+    client.getMyTasks(config.teamId),
+    folderId ? Promise.resolve([]) : client.getSpaces(config.teamId),
+    client.getCustomTaskTypes(config.teamId)
+  ]);
+  const typeMap = buildTypeMap(customTypes);
+  let sprintLists;
+  if (folderId) {
+    sprintLists = await client.getFolderLists(folderId);
+  } else {
+    let spaces;
+    if (opts.space) {
+      spaces = allSpaces.filter(
+        (s) => s.name.toLowerCase().includes(opts.space.toLowerCase()) || s.id === opts.space
+      );
+      if (spaces.length === 0) {
+        throw new Error(
+          `No space matching "${opts.space}" found. Use \`cup spaces\` to list available spaces.`
+        );
+      }
+    } else {
+      const mySpaceIds = new Set(
+        myTasks.map((t) => t.space?.id).filter((id) => Boolean(id))
+      );
+      spaces = findRelatedSpaces(mySpaceIds, allSpaces);
+    }
+    const foldersBySpace = await Promise.all(spaces.map((space) => client.getFolders(space.id)));
+    const sprintFolders = foldersBySpace.flat().filter((f) => {
+      const lower = f.name.toLowerCase();
+      return SPRINT_KEYWORDS.some((kw) => lower.includes(kw));
+    });
+    const listsByFolder = await Promise.all(
+      sprintFolders.map((folder) => client.getFolderLists(folder.id))
+    );
+    sprintLists = listsByFolder.flat();
+  }
+  let activeList = findActiveSprintList(sprintLists);
+  if (!activeList && sprintLists.length > 1 && isTTY()) {
+    const choice = await select2({
+      message: "Multiple sprint lists found. Which one?",
+      choices: sprintLists.map((l) => ({
+        name: `${l.name} (${l.id})`,
+        value: l
+      }))
+    });
+    activeList = choice;
+  }
+  if (!activeList && sprintLists.length > 1) {
+    process.stderr.write(
+      `Multiple sprint lists found:
+${sprintLists.map((l) => `  - ${l.name} (${l.id})`).join("\n")}
+Using: ${sprintLists[sprintLists.length - 1].name}
+`
+    );
+    activeList = sprintLists[sprintLists.length - 1] ?? null;
+  }
+  if (!activeList) {
+    throw new Error(
+      'No sprint list found. Ensure sprint folders contain "sprint", "iteration", "cycle", or "scrum" in their name.'
+    );
+  }
+  process.stderr.write(`Active sprint: ${activeList.name}
 `);
+  const me = await client.getMe();
+  const viewData = await client.getListViews(activeList.id);
+  const listView = viewData.required_views?.list;
+  let allTasks;
+  if (listView) {
+    allTasks = await client.getViewTasks(listView.id);
+  } else {
+    allTasks = await client.getTasksFromList(activeList.id);
+  }
+  let sprintTasks = allTasks.filter((t) => t.assignees.some((a) => Number(a.id) === me.id));
+  if (!opts.includeClosed) {
+    sprintTasks = sprintTasks.filter((t) => !isDoneStatus(t.status.status));
+  }
+  const filtered = opts.status ? sprintTasks.filter((t) => t.status.status.toLowerCase() === opts.status.toLowerCase()) : sprintTasks;
+  const summaries = filtered.map((t) => summarize(t, typeMap));
+  await printTasks(summaries, opts.json ?? false, config);
 }
 
 // src/commands/sprints.ts
-import chalk from "chalk";
+import chalk3 from "chalk";
 var SPRINT_COLUMNS = [
   { key: "id", label: "ID" },
   {
     key: "sprint",
     label: "SPRINT",
     maxWidth: 60,
-    format: (v, row) => row.active ? chalk.green(v) : v
+    format: (v, row) => row.active ? chalk3.green(v) : v
   },
   { key: "dates", label: "DATES" }
 ];
@@ -468,7 +2415,7 @@ async function postComment(config, taskId, text, notifyAll) {
 }
 
 // src/commands/comments.ts
-import chalk2 from "chalk";
+import chalk4 from "chalk";
 async function fetchComments(config, taskId) {
   const client = new ClickUpClient(config);
   const comments = await client.getTaskComments(taskId);
@@ -492,11 +2439,11 @@ function printComments(comments, forceJson) {
     console.log("No comments found.");
     return;
   }
-  const separator = chalk2.dim("-".repeat(60));
+  const separator = chalk4.dim("-".repeat(60));
   for (let i = 0; i < comments.length; i++) {
     const c = comments[i];
     if (i > 0) console.log(separator);
-    console.log(`${chalk2.bold(c.user)}  ${chalk2.dim(formatTimestamp(c.date))}`);
+    console.log(`${chalk4.bold(c.user)}  ${chalk4.dim(formatTimestamp(c.date))}`);
     console.log(c.text);
     if (i < comments.length - 1) console.log("");
   }
@@ -806,7 +2753,7 @@ async function openTask(config, query, opts = {}) {
 }
 
 // src/commands/summary.ts
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 var IN_PROGRESS_PATTERNS = ["in progress", "in review", "code review", "doing"];
 function isCompletedRecently(task, cutoff) {
   if (!isDoneStatus(task.status.status)) return false;
@@ -844,9 +2791,9 @@ function categorizeTasks(tasks, hoursBack, typeMap) {
 }
 function colorSectionLabel(label) {
   const lower = label.toLowerCase();
-  if (lower.includes("completed")) return chalk3.green(label);
-  if (lower.includes("progress")) return chalk3.yellow(label);
-  if (lower.includes("overdue")) return chalk3.red(label);
+  if (lower.includes("completed")) return chalk5.green(label);
+  if (lower.includes("progress")) return chalk5.yellow(label);
+  if (lower.includes("overdue")) return chalk5.red(label);
   return label;
 }
 function printSection(label, tasks) {
@@ -948,7 +2895,7 @@ function setConfigValue(key, value, profileName) {
   }
   writeConfig(merged, profileName);
 }
-function configPath() {
+function configPath2() {
   return getConfigPath();
 }
 
@@ -975,7 +2922,7 @@ async function assignTask(config, taskId, opts) {
 }
 
 // src/commands/activity.ts
-import chalk4 from "chalk";
+import chalk6 from "chalk";
 async function fetchActivity(config, taskId) {
   const client = new ClickUpClient(config);
   const [task, rawComments] = await Promise.all([
@@ -1007,8 +2954,8 @@ ${commentsMd}`);
   }
   console.log(formatTaskDetail(result.task));
   console.log("");
-  console.log(chalk4.bold("Comments"));
-  console.log(chalk4.dim("-".repeat(60)));
+  console.log(chalk6.bold("Comments"));
+  console.log(chalk6.dim("-".repeat(60)));
   if (result.comments.length === 0) {
     console.log("No comments.");
     return;
@@ -1017,15 +2964,15 @@ ${commentsMd}`);
     const c = result.comments[i];
     if (i > 0) {
       console.log("");
-      console.log(chalk4.dim("-".repeat(60)));
+      console.log(chalk6.dim("-".repeat(60)));
     }
-    console.log(`${chalk4.bold(c.user)}  ${chalk4.dim(formatTimestamp(c.date))}`);
+    console.log(`${chalk6.bold(c.user)}  ${chalk6.dim(formatTimestamp(c.date))}`);
     console.log(c.text);
   }
 }
 
 // src/commands/time-in-status.ts
-import chalk5 from "chalk";
+import chalk7 from "chalk";
 function transformResponse(taskId, data) {
   const entries = [];
   for (const entry of data.status_history ?? []) {
@@ -1095,11 +3042,11 @@ function printTimeInStatus(result, forceJson) {
   const columns = [
     { key: "status", label: "STATUS", maxWidth: 25, format: (v) => colorStatus(v) },
     { key: "duration", label: "DURATION" },
-    { key: "current", label: "", format: (v) => v ? chalk5.green("\u25C0") : "" }
+    { key: "current", label: "", format: (v) => v ? chalk7.green("\u25C0") : "" }
   ];
   console.log(formatTable(rows, columns));
   console.log("");
-  console.log(`${chalk5.bold("Total:")} ${result.total}`);
+  console.log(`${chalk7.bold("Total:")} ${result.total}`);
 }
 
 // src/commands/metadata.ts
@@ -1244,12 +3191,12 @@ var commandMetadata = [
   },
   {
     name: "comment-delete",
-    description: "Delete a comment",
-    flags: ["--mine", "--match", "--json"],
+    description: "Delete a comment by ID, or use --task with --mine to find and delete your comment",
+    flags: ["--task", "--mine", "--match", "--json"],
     quickReference: [
       {
         section: "write",
-        usage: "comment-delete <commentId>",
+        usage: "comment-delete [commentId]",
         description: "Delete a comment"
       }
     ]
@@ -2483,8 +4430,9 @@ ${renderZshTopLevelCommands(name)}
         comment-delete)
           _arguments \\
             '1:comment_id:' \\
+            '--task[Task to search for your comment (requires --mine)]:task_id:' \\
             '--mine[Delete one of my comments from the specified task]' \\
-            '--match[Only match comments containing this text]:text:' \\
+            '--match[Only match comments containing this text (requires --mine)]:text:' \\
             '--json[Force JSON output]'
           ;;
         replies)
@@ -3014,18 +4962,18 @@ function generateCompletion(shell, name = "cup") {
 
 // src/commands/skill.ts
 import { readFileSync, realpathSync, mkdirSync, copyFileSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import chalk6 from "chalk";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+import chalk8 from "chalk";
 function skillPath() {
   if (!process.argv[1]) {
     throw new Error("Cannot determine install path. Run with: cup skill");
   }
   const entryPoint = realpathSync(process.argv[1]);
   const packageRoot = dirname(dirname(entryPoint));
-  const candidate = join(packageRoot, "skills", "clickup-cli", "SKILL.md");
+  const candidate = join2(packageRoot, "skills", "clickup-cli", "SKILL.md");
   if (existsSync(candidate)) return candidate;
-  const altCandidate = join(dirname(entryPoint), "..", "skills", "clickup-cli", "SKILL.md");
+  const altCandidate = join2(dirname(entryPoint), "..", "skills", "clickup-cli", "SKILL.md");
   if (existsSync(altCandidate)) return altCandidate;
   throw new Error("SKILL.md not found. Reinstall with: npm install -g @krodak/clickup-cli");
 }
@@ -3033,11 +4981,11 @@ function printSkill() {
   return readFileSync(skillPath(), "utf-8");
 }
 function getAgentTargets() {
-  const home = homedir();
+  const home = homedir2();
   const targets = [
-    { name: "Claude Code", dir: join(home, ".claude", "skills", "clickup") },
-    { name: "Codex", dir: join(home, ".agents", "skills", "clickup") },
-    { name: "OpenCode", dir: join(home, ".config", "opencode", "skills", "clickup") }
+    { name: "Claude Code", dir: join2(home, ".claude", "skills", "clickup") },
+    { name: "Codex", dir: join2(home, ".agents", "skills", "clickup") },
+    { name: "OpenCode", dir: join2(home, ".config", "opencode", "skills", "clickup") }
   ];
   return targets.map((t) => ({
     ...t,
@@ -3049,11 +4997,11 @@ async function installSkillInteractive() {
   const source = skillPath();
   const installed = [];
   if (isTTY()) {
-    const { checkbox } = await import("@inquirer/prompts");
-    const selected = await checkbox({
+    const { checkbox: checkbox2 } = await import("@inquirer/prompts");
+    const selected = await checkbox2({
       message: "Install skill for which agents?",
       choices: targets.map((t) => ({
-        name: `${t.name}${t.detected ? chalk6.dim(" (detected)") : ""}`,
+        name: `${t.name}${t.detected ? chalk8.dim(" (detected)") : ""}`,
         value: t.name,
         checked: t.detected
       }))
@@ -3065,7 +5013,7 @@ async function installSkillInteractive() {
       const target = targets.find((t) => t.name === name);
       if (!target) continue;
       if (!existsSync(target.dir)) mkdirSync(target.dir, { recursive: true });
-      const dest = join(target.dir, "SKILL.md");
+      const dest = join2(target.dir, "SKILL.md");
       copyFileSync(source, dest);
       installed.push(`${target.name}: ${dest}`);
     }
@@ -3078,7 +5026,7 @@ async function installSkillInteractive() {
     }
     for (const target of detected) {
       if (!existsSync(target.dir)) mkdirSync(target.dir, { recursive: true });
-      const dest = join(target.dir, "SKILL.md");
+      const dest = join2(target.dir, "SKILL.md");
       copyFileSync(source, dest);
       installed.push(`${target.name}: ${dest}`);
     }
@@ -3298,8 +5246,8 @@ async function deleteTaskCommand(config, taskId, opts) {
       throw new Error("Destructive operation requires --confirm flag in non-interactive mode");
     }
     const task = await client.getTask(taskId);
-    const { confirm: confirm2 } = await import("@inquirer/prompts");
-    const confirmed = await confirm2({
+    const { confirm: confirm3 } = await import("@inquirer/prompts");
+    const confirmed = await confirm3({
       message: `Delete task "${task.name}" (${task.id})? This cannot be undone.`,
       default: false
     });
@@ -3319,8 +5267,8 @@ async function archiveTaskCommand(config, taskId, opts) {
       throw new Error(`Destructive operation requires --confirm flag in non-interactive mode`);
     }
     const task = await client.getTask(taskId);
-    const { confirm: confirm2 } = await import("@inquirer/prompts");
-    const confirmed = await confirm2({
+    const { confirm: confirm3 } = await import("@inquirer/prompts");
+    const confirmed = await confirm3({
       message: `${opts.unarchive ? "Unarchive" : "Archive"} task "${task.name}" (${task.id})?`,
       default: false
     });
@@ -3371,7 +5319,7 @@ async function manageTags(config, taskId, opts) {
 }
 
 // src/commands/checklist.ts
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 async function viewChecklists(config, taskId) {
   const client = new ClickUpClient(config);
   const task = await client.getTask(taskId);
@@ -3404,14 +5352,14 @@ function formatChecklists(checklists) {
   const lines = [];
   for (const cl of checklists) {
     const resolved = cl.items.filter((i) => i.resolved).length;
-    lines.push(chalk7.bold(`${cl.name} (${resolved}/${cl.items.length})`));
-    lines.push(chalk7.dim(`  ID: ${cl.id}`));
+    lines.push(chalk9.bold(`${cl.name} (${resolved}/${cl.items.length})`));
+    lines.push(chalk9.dim(`  ID: ${cl.id}`));
     for (const item of cl.items) {
-      const check = item.resolved ? chalk7.green("[x]") : chalk7.dim("[ ]");
-      const name = item.resolved ? chalk7.dim(item.name) : item.name;
-      const assignee = item.assignee ? chalk7.dim(` @${item.assignee.username}`) : "";
+      const check = item.resolved ? chalk9.green("[x]") : chalk9.dim("[ ]");
+      const name = item.resolved ? chalk9.dim(item.name) : item.name;
+      const assignee = item.assignee ? chalk9.dim(` @${item.assignee.username}`) : "";
       lines.push(`  ${check} ${name}${assignee}`);
-      lines.push(chalk7.dim(`      item-id: ${item.id}`));
+      lines.push(chalk9.dim(`      item-id: ${item.id}`));
     }
   }
   return lines.join("\n");
@@ -3470,7 +5418,7 @@ async function deleteCommentByTaskSelection(config, taskId, options) {
 }
 
 // src/commands/replies.ts
-import chalk8 from "chalk";
+import chalk10 from "chalk";
 async function getReplies(config, commentId) {
   const client = new ClickUpClient(config);
   return client.getThreadedComments(commentId);
@@ -3485,7 +5433,7 @@ function formatReplies(replies) {
   return replies.map((r) => {
     const user = r.user?.username ?? "Unknown";
     const date = formatTimestamp(Number(r.date));
-    return `${chalk8.bold(user)} ${chalk8.dim(date)}
+    return `${chalk10.bold(user)} ${chalk10.dim(date)}
   ${r.comment_text}`;
   }).join("\n\n");
 }
@@ -3548,7 +5496,7 @@ function formatDocsMarkdown(docs) {
 }
 
 // src/commands/doc.ts
-import chalk9 from "chalk";
+import chalk11 from "chalk";
 async function getDocInfo(config, docId) {
   const client = new ClickUpClient(config);
   const [doc, pages] = await Promise.all([
@@ -3560,14 +5508,14 @@ async function getDocInfo(config, docId) {
 function formatDocInfo(doc, pages, indent = 0) {
   const lines = [];
   if (indent === 0) {
-    lines.push(`${chalk9.bold(doc.name)} ${chalk9.dim(doc.id)}`);
+    lines.push(`${chalk11.bold(doc.name)} ${chalk11.dim(doc.id)}`);
     if (pages.length === 0) {
       lines.push("  (no pages)");
     }
   }
   for (const page of pages) {
     const prefix = "  ".repeat(indent + 1);
-    lines.push(`${prefix}${page.name} ${chalk9.dim(page.id)}`);
+    lines.push(`${prefix}${page.name} ${chalk11.dim(page.id)}`);
     if (page.pages && page.pages.length > 0) {
       lines.push(formatDocInfo(doc, page.pages, indent + 1));
     }
@@ -3646,7 +5594,7 @@ async function deleteDocPage(config, docId, pageId) {
 }
 
 // src/commands/folders.ts
-import chalk10 from "chalk";
+import chalk12 from "chalk";
 async function listFolders(config, spaceId, nameFilter) {
   const client = new ClickUpClient(config);
   const folders = await client.getFolders(spaceId);
@@ -3665,9 +5613,9 @@ async function listFolders(config, spaceId, nameFilter) {
 function formatFolders(folders) {
   if (folders.length === 0) return "No folders found";
   return folders.map((f) => {
-    const header = `${chalk10.bold(f.name)} ${chalk10.dim(f.id)}`;
+    const header = `${chalk12.bold(f.name)} ${chalk12.dim(f.id)}`;
     if (f.lists.length === 0) return header;
-    const listLines = f.lists.map((l) => `  ${chalk10.dim(">")} ${l.name} ${chalk10.dim(l.id)}`);
+    const listLines = f.lists.map((l) => `  ${chalk12.dim(">")} ${l.name} ${chalk12.dim(l.id)}`);
     return [header, ...listLines].join("\n");
   }).join("\n\n");
 }
@@ -3682,13 +5630,13 @@ function formatFoldersMarkdown(folders) {
 }
 
 // src/commands/time.ts
-import chalk11 from "chalk";
+import chalk13 from "chalk";
 var TIME_COLUMNS = [
   { key: "task", label: "Task", maxWidth: 35 },
   { key: "duration", label: "Duration", maxWidth: 10 },
   { key: "date", label: "Date", maxWidth: 20 },
   { key: "description", label: "Description", maxWidth: 30 },
-  { key: "status", label: "", maxWidth: 10, format: (v) => v === "RUNNING" ? chalk11.green(v) : "" }
+  { key: "status", label: "", maxWidth: 10, format: (v) => v === "RUNNING" ? chalk13.green(v) : "" }
 ];
 async function startTimer(config, taskId, description) {
   const client = new ClickUpClient(config);
@@ -3784,7 +5732,7 @@ function formatTimeEntriesMarkdown(entries) {
 }
 
 // src/commands/tags.ts
-import chalk12 from "chalk";
+import chalk14 from "chalk";
 var TAG_COLUMNS = [
   { key: "name", label: "Name", maxWidth: 40 },
   { key: "fg", label: "FG", maxWidth: 10 },
@@ -3817,13 +5765,13 @@ function formatTags(tags) {
   if (tags.length === 0) return "No tags found";
   if (isTTY()) {
     const rows = tags.map((t) => ({
-      name: t.tag_bg ? chalk12.bgHex(t.tag_bg).hex(t.tag_fg || "#ffffff")(` ${t.name} `) : chalk12.bold(t.name),
+      name: t.tag_bg ? chalk14.bgHex(t.tag_bg).hex(t.tag_fg || "#ffffff")(` ${t.name} `) : chalk14.bold(t.name),
       fg: t.tag_fg || "",
       bg: t.tag_bg || ""
     }));
     return formatTable(rows, TAG_COLUMNS);
   }
-  return tags.map((t) => chalk12.bold(t.name)).join(", ");
+  return tags.map((t) => chalk14.bold(t.name)).join(", ");
 }
 function formatTagsMarkdown(tags) {
   if (tags.length === 0) return "No tags found";
@@ -3858,7 +5806,7 @@ function formatMembersMarkdown(members) {
 }
 
 // src/commands/fields.ts
-import chalk13 from "chalk";
+import chalk15 from "chalk";
 var FIELD_COLUMNS = [
   { key: "id", label: "ID", maxWidth: 20 },
   { key: "name", label: "Name", maxWidth: 30 },
@@ -3867,7 +5815,7 @@ var FIELD_COLUMNS = [
     key: "required",
     label: "Required",
     maxWidth: 10,
-    format: (v) => v === "yes" ? chalk13.yellow(v) : chalk13.dim(v)
+    format: (v) => v === "yes" ? chalk15.yellow(v) : chalk15.dim(v)
   },
   { key: "options", label: "Options", maxWidth: 40 }
 ];
@@ -3974,13 +5922,13 @@ async function bulkTag(config, tagName, taskIds, action) {
 }
 
 // src/commands/goals.ts
-import chalk14 from "chalk";
+import chalk16 from "chalk";
 function colorProgress(value) {
   const num = parseInt(value, 10);
   if (isNaN(num)) return value;
-  if (num >= 75) return chalk14.green(value);
-  if (num >= 25) return chalk14.yellow(value);
-  return chalk14.red(value);
+  if (num >= 75) return chalk16.green(value);
+  if (num >= 25) return chalk16.yellow(value);
+  return chalk16.red(value);
 }
 var GOAL_COLUMNS = [
   { key: "id", label: "ID", maxWidth: 15 },
@@ -4074,14 +6022,14 @@ function formatKeyResultsMarkdown(keyResults) {
 }
 
 // src/commands/task-types.ts
-import chalk15 from "chalk";
+import chalk17 from "chalk";
 async function listTaskTypes(config) {
   const client = new ClickUpClient(config);
   return client.getCustomTaskTypes(config.teamId);
 }
 function formatTaskTypes(types) {
   if (types.length === 0) return "No custom task types";
-  return types.map((t) => `${chalk15.bold(t.name)} ${chalk15.dim(`(${t.id})`)}`).join("\n");
+  return types.map((t) => `${chalk17.bold(t.name)} ${chalk17.dim(`(${t.id})`)}`).join("\n");
 }
 function formatTaskTypesMarkdown(types) {
   if (types.length === 0) return "No custom task types";
@@ -4089,14 +6037,14 @@ function formatTaskTypesMarkdown(types) {
 }
 
 // src/commands/templates.ts
-import chalk16 from "chalk";
+import chalk18 from "chalk";
 async function listTemplates(config) {
   const client = new ClickUpClient(config);
   return client.getTaskTemplates(config.teamId);
 }
 function formatTemplates(templates) {
   if (templates.length === 0) return "No task templates";
-  return templates.map((t) => `${chalk16.bold(t.name)} ${chalk16.dim(`(${t.id})`)}`).join("\n");
+  return templates.map((t) => `${chalk18.bold(t.name)} ${chalk18.dim(`(${t.id})`)}`).join("\n");
 }
 function formatTemplatesMarkdown(templates) {
   if (templates.length === 0) return "No task templates";
@@ -4104,14 +6052,14 @@ function formatTemplatesMarkdown(templates) {
 }
 
 // src/commands/list-templates.ts
-import chalk17 from "chalk";
+import chalk19 from "chalk";
 async function listListTemplates(config) {
   const client = new ClickUpClient(config);
   return client.getListTemplates(config.teamId);
 }
 function formatListTemplates(templates) {
   if (templates.length === 0) return "No list templates";
-  return templates.map((t) => `${chalk17.bold(t.name)} ${chalk17.dim(`(${t.id})`)}`).join("\n");
+  return templates.map((t) => `${chalk19.bold(t.name)} ${chalk19.dim(`(${t.id})`)}`).join("\n");
 }
 function formatListTemplatesMarkdown(templates) {
   if (templates.length === 0) return "No list templates";
@@ -4119,14 +6067,14 @@ function formatListTemplatesMarkdown(templates) {
 }
 
 // src/commands/folder-templates.ts
-import chalk18 from "chalk";
+import chalk20 from "chalk";
 async function listFolderTemplates(config) {
   const client = new ClickUpClient(config);
   return client.getFolderTemplates(config.teamId);
 }
 function formatFolderTemplates(templates) {
   if (templates.length === 0) return "No folder templates";
-  return templates.map((t) => `${chalk18.bold(t.name)} ${chalk18.dim(`(${t.id})`)}`).join("\n");
+  return templates.map((t) => `${chalk20.bold(t.name)} ${chalk20.dim(`(${t.id})`)}`).join("\n");
 }
 function formatFolderTemplatesMarkdown(templates) {
   if (templates.length === 0) return "No folder templates";
@@ -4149,7 +6097,7 @@ async function createListFromTemplate(config, name, opts) {
 }
 
 // src/commands/views.ts
-import chalk19 from "chalk";
+import chalk21 from "chalk";
 async function listViews(config, id, container = "list") {
   const client = new ClickUpClient(config);
   if (container === "space") return client.getSpaceViews(id);
@@ -4160,7 +6108,7 @@ async function listViews(config, id, container = "list") {
 }
 function formatViews(views) {
   if (views.length === 0) return "No views";
-  return views.map((v) => `${chalk19.bold(v.name)} ${chalk19.dim(`(${v.id})`)} ${chalk19.dim(v.type)}`).join("\n");
+  return views.map((v) => `${chalk21.bold(v.name)} ${chalk21.dim(`(${v.id})`)} ${chalk21.dim(v.type)}`).join("\n");
 }
 function formatViewsMarkdown(views) {
   if (views.length === 0) return "No views";
@@ -4168,20 +6116,20 @@ function formatViewsMarkdown(views) {
 }
 
 // src/commands/view.ts
-import chalk20 from "chalk";
+import chalk22 from "chalk";
 async function getView(config, viewId) {
   const client = new ClickUpClient(config);
   return client.getView(viewId);
 }
 function formatView(view) {
   const lines = [];
-  lines.push(chalk20.bold.underline(view.name));
+  lines.push(chalk22.bold.underline(view.name));
   lines.push("");
-  lines.push(`  ${chalk20.bold("ID")}     ${view.id}`);
-  lines.push(`  ${chalk20.bold("Type")}   ${view.type}`);
-  if (view.visibility) lines.push(`  ${chalk20.bold("Visibility")} ${view.visibility}`);
-  if (view.date_created) lines.push(`  ${chalk20.bold("Created")} ${formatDate(view.date_created)}`);
-  if (view.protected !== void 0) lines.push(`  ${chalk20.bold("Protected")} ${view.protected}`);
+  lines.push(`  ${chalk22.bold("ID")}     ${view.id}`);
+  lines.push(`  ${chalk22.bold("Type")}   ${view.type}`);
+  if (view.visibility) lines.push(`  ${chalk22.bold("Visibility")} ${view.visibility}`);
+  if (view.date_created) lines.push(`  ${chalk22.bold("Created")} ${formatDate(view.date_created)}`);
+  if (view.protected !== void 0) lines.push(`  ${chalk22.bold("Protected")} ${view.protected}`);
   return lines.join("\n");
 }
 function formatViewMarkdown(view) {
@@ -4265,8 +6213,8 @@ async function deleteViewCommand(config, viewId, opts) {
       throw new Error("Destructive operation requires --confirm flag in non-interactive mode");
     }
     const view = await client.getView(viewId);
-    const { confirm: confirm2 } = await import("@inquirer/prompts");
-    const confirmed = await confirm2({
+    const { confirm: confirm3 } = await import("@inquirer/prompts");
+    const confirmed = await confirm3({
       message: `Delete view "${view.name}" (${viewId})? This cannot be undone.`,
       default: false
     });
@@ -4625,7 +6573,6 @@ function buildProgram(programName = basename(process.argv[1] ?? "cup")) {
     wrapAction(async (opts) => {
       const config = loadConfig(getProfileName());
       if (opts.list === "sprint:current") {
-        const { resolveActiveSprintListId } = await import("./sprint-NLMMC4RB.js");
         opts.list = await resolveActiveSprintListId(config);
       }
       if (opts.assignee === "me") {
@@ -4707,14 +6654,33 @@ function buildProgram(programName = basename(process.argv[1] ?? "cup")) {
       }
     )
   );
-  program.command("comment-delete <commentId>").description("Delete a comment").option("--mine", "Delete one of my comments from the specified task instead of by comment ID").option("--match <text>", "Only match my task comments containing this text").option("--json", "Force JSON output even in terminal").action(
+  program.command("comment-delete [commentId]").description(
+    "Delete a comment by ID, or use --task with --mine to find and delete your comment"
+  ).option("--task <taskId>", "Task to search for your comment (requires --mine)").option("--mine", "Delete one of my comments from the specified task").option("--match <text>", "Only match comments containing this text (requires --mine)").option("--json", "Force JSON output even in terminal").action(
     wrapAction(
       async (commentId, opts) => {
+        if (opts.mine && !opts.task) {
+          throw new Error("--mine requires --task <taskId>");
+        }
+        if (opts.match && !opts.mine) {
+          throw new Error("--match requires --mine");
+        }
         const config = loadConfig(getProfileName());
-        const result = opts.mine || opts.match ? await deleteCommentByTaskSelection(config, commentId, {
-          mine: opts.mine,
-          match: opts.match
-        }) : (await deleteComment(config, commentId), { commentId });
+        let result;
+        if (opts.task) {
+          if (!opts.mine) {
+            throw new Error("--task requires --mine");
+          }
+          result = await deleteCommentByTaskSelection(config, opts.task, {
+            mine: opts.mine,
+            match: opts.match
+          });
+        } else if (commentId) {
+          await deleteComment(config, commentId);
+          result = { commentId };
+        } else {
+          throw new Error("Provide a comment ID or use --task <taskId> --mine");
+        }
         if (shouldOutputJson(opts.json ?? false)) {
           console.log(JSON.stringify({ success: true, ...result }, null, 2));
         } else {
@@ -4946,7 +6912,6 @@ function buildProgram(programName = basename(process.argv[1] ?? "cup")) {
     wrapAction(async (taskId, opts) => {
       const config = loadConfig(getProfileName());
       if (opts.to === "sprint:current") {
-        const { resolveActiveSprintListId } = await import("./sprint-NLMMC4RB.js");
         opts.to = await resolveActiveSprintListId(config);
       }
       const message = await moveTask(config, taskId, opts);
@@ -5988,7 +7953,7 @@ function buildProgram(programName = basename(process.argv[1] ?? "cup")) {
   );
   profileCmd.command("add <name>").description("Add a new profile").action(
     wrapAction(async (name) => {
-      const { password: password2, select: select2 } = await import("@inquirer/prompts");
+      const { password: password2, select: select3 } = await import("@inquirer/prompts");
       const apiToken = (await password2({ message: "ClickUp API token (pk_...):" })).trim();
       if (!apiToken.startsWith("pk_")) throw new Error("Token must start with pk_");
       const client = new ClickUpClient({ apiToken });
@@ -6003,7 +7968,7 @@ function buildProgram(programName = basename(process.argv[1] ?? "cup")) {
         process.stdout.write(`Workspace: ${teams[0].name}
 `);
       } else {
-        teamId = await select2({
+        teamId = await select3({
           message: "Select workspace:",
           choices: teams.map((t) => ({ name: t.name, value: t.id }))
         });
@@ -6041,7 +8006,7 @@ function buildProgram(programName = basename(process.argv[1] ?? "cup")) {
   );
   configCmd.command("path").description("Print config file path").action(
     wrapAction(async () => {
-      console.log(configPath());
+      console.log(configPath2());
     })
   );
   program.command("completion <shell>").description("Output shell completion script (bash, zsh, fish)").action(