exponential-cli 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command5 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/auth.ts
 import { Command } from "commander";
@@ -244,6 +244,30 @@ function transformWorkspace(workspace) {
     type: workspace.type
   };
 }
+function outputActionJson(action) {
+  const output = transformAction(action);
+  console.log(JSON.stringify(output, null, 2));
+}
+function outputActionPretty(action) {
+  const statusColor = getKanbanStatusColor(action.kanbanStatus);
+  const statusBadge = action.kanbanStatus ? chalk3[statusColor](`[${action.kanbanStatus}]`) : chalk3.gray("[NO STATUS]");
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`
+${statusBadge} ${chalk3.bold(action.name)}`);
+  console.log(chalk3.gray(`  ID: ${action.id}`));
+  if (action.project) {
+    console.log(`  ${chalk3.cyan("Project:")} ${action.project.name}`);
+  }
+  console.log(`  ${chalk3.magenta("Priority:")} ${action.priority}`);
+  if (action.dueDate) {
+    const dueDate = new Date(action.dueDate);
+    console.log(`  ${chalk3.yellow("Due:")} ${formatDate(dueDate)}`);
+  }
+  if (action.description) {
+    console.log(`  ${chalk3.gray("Description:")} ${action.description.substring(0, 100)}${action.description.length > 100 ? "..." : ""}`);
+  }
+  console.log();
+}
 function outputActionsJson(actions, filters = {}) {
   const output = {
     actions: actions.map(transformAction),
@@ -365,8 +389,650 @@ function formatDate(date) {
     day: "numeric"
   });
 }
+function outputContactJson(contact) {
+  console.log(JSON.stringify(transformContact(contact), null, 2));
+}
+function outputContactPretty(contact) {
+  const name = [contact.firstName, contact.lastName].filter(Boolean).join(" ") || chalk3.gray("(no name)");
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`
+${chalk3.bold(name)}`);
+  console.log(chalk3.gray(`  ID: ${contact.id}`));
+  if (contact.email) console.log(`  ${chalk3.cyan("Email:")} ${contact.email}`);
+  if (contact.phone) console.log(`  ${chalk3.cyan("Phone:")} ${contact.phone}`);
+  if (contact.telegram) console.log(`  ${chalk3.cyan("Telegram:")} ${contact.telegram}`);
+  if (contact.linkedIn) console.log(`  ${chalk3.cyan("LinkedIn:")} ${contact.linkedIn}`);
+  if (contact.twitter) console.log(`  ${chalk3.cyan("Twitter:")} ${contact.twitter}`);
+  if (contact.github) console.log(`  ${chalk3.cyan("GitHub:")} ${contact.github}`);
+  if (contact.bluesky) console.log(`  ${chalk3.cyan("Bluesky:")} ${contact.bluesky}`);
+  if (contact.about) console.log(`  ${chalk3.gray("About:")} ${contact.about.substring(0, 120)}${contact.about.length > 120 ? "..." : ""}`);
+  if (contact.profileType) console.log(`  ${chalk3.magenta("Type:")} ${contact.profileType}`);
+  if (contact.skills?.length) console.log(`  ${chalk3.yellow("Skills:")} ${contact.skills.join(", ")}`);
+  if (contact.tags?.length) console.log(`  ${chalk3.yellow("Tags:")} ${contact.tags.join(", ")}`);
+  if (contact.organization) console.log(`  ${chalk3.green("Org:")} ${contact.organization.name}`);
+  if (contact.connectionScore != null) console.log(`  ${chalk3.blue("Connection Score:")} ${contact.connectionScore}`);
+  if (contact.lastInteractionAt) console.log(`  ${chalk3.gray("Last Interaction:")} ${formatDate(new Date(contact.lastInteractionAt))} (${contact.lastInteractionType ?? ""})`);
+  console.log();
+}
+function outputContactsJson(contacts, nextCursor) {
+  console.log(JSON.stringify({
+    contacts: contacts.map(transformContact),
+    total: contacts.length,
+    nextCursor: nextCursor ?? null
+  }, null, 2));
+}
+function outputContactsPretty(contacts) {
+  if (contacts.length === 0) {
+    console.log(chalk3.gray("No contacts found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Contacts (${contacts.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const contact of contacts) {
+    const name = [contact.firstName, contact.lastName].filter(Boolean).join(" ") || chalk3.gray("(no name)");
+    console.log(`
+${chalk3.bold(name)}`);
+    console.log(chalk3.gray(`  ID: ${contact.id}`));
+    if (contact.email) console.log(`  ${chalk3.cyan("Email:")} ${contact.email}`);
+    if (contact.organization) console.log(`  ${chalk3.green("Org:")} ${contact.organization.name}`);
+    if (contact.tags?.length) console.log(`  ${chalk3.yellow("Tags:")} ${contact.tags.join(", ")}`);
+  }
+  console.log();
+}
+function transformContact(contact) {
+  return {
+    id: contact.id,
+    workspaceId: contact.workspaceId,
+    firstName: contact.firstName,
+    lastName: contact.lastName,
+    email: contact.email,
+    phone: contact.phone,
+    linkedIn: contact.linkedIn,
+    telegram: contact.telegram,
+    twitter: contact.twitter,
+    github: contact.github,
+    bluesky: contact.bluesky,
+    about: contact.about,
+    profileType: contact.profileType,
+    skills: contact.skills,
+    tags: contact.tags,
+    organizationId: contact.organizationId,
+    organization: contact.organization ?? null,
+    connectionScore: contact.connectionScore,
+    lastInteractionAt: contact.lastInteractionAt ? new Date(contact.lastInteractionAt).toISOString() : null,
+    lastInteractionType: contact.lastInteractionType,
+    createdAt: new Date(contact.createdAt).toISOString(),
+    updatedAt: new Date(contact.updatedAt).toISOString()
+  };
+}
+function outputInteractionJson(interaction) {
+  console.log(JSON.stringify(interaction, null, 2));
+}
+function outputInteractionPretty(interaction) {
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`  ${chalk3.cyan("Type:")} ${interaction.type} (${interaction.direction})`);
+  if (interaction.subject) console.log(`  ${chalk3.bold("Subject:")} ${interaction.subject}`);
+  if (interaction.notes) console.log(`  ${chalk3.gray("Notes:")} ${interaction.notes}`);
+  console.log();
+}
+function outputDealJson(deal) {
+  console.log(JSON.stringify(transformDeal(deal), null, 2));
+}
+function outputDealPretty(deal) {
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`
+${chalk3.bold(deal.title)}`);
+  console.log(chalk3.gray(`  ID: ${deal.id}`));
+  if (deal.stage) console.log(`  ${chalk3.blue("Stage:")} ${deal.stage.name}`);
+  if (deal.value != null) console.log(`  ${chalk3.green("Value:")} ${deal.currency} ${deal.value.toLocaleString()}`);
+  if (deal.probability != null) console.log(`  ${chalk3.yellow("Probability:")} ${deal.probability}%`);
+  if (deal.expectedCloseDate) console.log(`  ${chalk3.cyan("Expected Close:")} ${formatDate(new Date(deal.expectedCloseDate))}`);
+  if (deal.contact) {
+    const name = [deal.contact.firstName, deal.contact.lastName].filter(Boolean).join(" ");
+    if (name) console.log(`  ${chalk3.magenta("Contact:")} ${name}`);
+  }
+  if (deal.organization) console.log(`  ${chalk3.magenta("Org:")} ${deal.organization.name}`);
+  if (deal.assignedTo) console.log(`  ${chalk3.gray("Assigned:")} ${deal.assignedTo.name ?? deal.assignedTo.email ?? deal.assignedTo.id}`);
+  if (deal.description) console.log(`  ${chalk3.gray("Description:")} ${deal.description.substring(0, 120)}${deal.description.length > 120 ? "..." : ""}`);
+  console.log();
+}
+function outputDealsJson(deals) {
+  console.log(JSON.stringify({
+    deals: deals.map(transformDeal),
+    total: deals.length
+  }, null, 2));
+}
+function outputDealsPretty(deals) {
+  if (deals.length === 0) {
+    console.log(chalk3.gray("No deals found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Deals (${deals.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const deal of deals) {
+    const stageLabel = deal.stage ? chalk3.blue(`[${deal.stage.name}]`) : "";
+    const valueLabel = deal.value != null ? chalk3.green(` ${deal.currency} ${deal.value.toLocaleString()}`) : "";
+    console.log(`
+${stageLabel} ${chalk3.bold(deal.title)}${valueLabel}`);
+    console.log(chalk3.gray(`  ID: ${deal.id}`));
+    if (deal.contact) {
+      const name = [deal.contact.firstName, deal.contact.lastName].filter(Boolean).join(" ");
+      if (name) console.log(`  ${chalk3.magenta("Contact:")} ${name}`);
+    }
+    if (deal.probability != null) console.log(`  ${chalk3.yellow("Probability:")} ${deal.probability}%`);
+    if (deal.expectedCloseDate) console.log(`  ${chalk3.cyan("Close:")} ${formatDate(new Date(deal.expectedCloseDate))}`);
+  }
+  console.log();
+}
+function transformDeal(deal) {
+  return {
+    id: deal.id,
+    projectId: deal.projectId,
+    stageId: deal.stageId,
+    title: deal.title,
+    description: deal.description,
+    value: deal.value,
+    currency: deal.currency,
+    probability: deal.probability,
+    expectedCloseDate: deal.expectedCloseDate ? new Date(deal.expectedCloseDate).toISOString() : null,
+    closedAt: deal.closedAt ? new Date(deal.closedAt).toISOString() : null,
+    contactId: deal.contactId,
+    organizationId: deal.organizationId,
+    workspaceId: deal.workspaceId,
+    assignedToId: deal.assignedToId,
+    stage: deal.stage ? { id: deal.stage.id, name: deal.stage.name, color: deal.stage.color } : null,
+    contact: deal.contact ?? null,
+    organization: deal.organization ?? null,
+    assignedTo: deal.assignedTo ?? null,
+    createdAt: new Date(deal.createdAt).toISOString(),
+    updatedAt: new Date(deal.updatedAt).toISOString()
+  };
+}
+function outputPipelineJson(pipeline) {
+  console.log(JSON.stringify({
+    id: pipeline.id,
+    name: pipeline.name,
+    workspaceId: pipeline.workspaceId,
+    status: pipeline.status,
+    stages: pipeline.pipelineStages.map((s) => ({
+      id: s.id,
+      name: s.name,
+      color: s.color,
+      order: s.order,
+      type: s.type,
+      dealCount: s._count?.deals ?? null
+    }))
+  }, null, 2));
+}
+function outputPipelinePretty(pipeline) {
+  console.log(chalk3.bold(`
+Pipeline: ${pipeline.name}`));
+  console.log(chalk3.gray(`  ID: ${pipeline.id}`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const stage of pipeline.pipelineStages) {
+    const count = stage._count?.deals != null ? chalk3.gray(` (${stage._count.deals} deals)`) : "";
+    console.log(`  ${chalk3.bold(stage.name)}${count} \u2014 ${chalk3.gray(stage.type)}`);
+  }
+  console.log();
+}
+function outputStagesJson(stages) {
+  console.log(JSON.stringify({
+    stages: stages.map((s) => ({
+      id: s.id,
+      name: s.name,
+      color: s.color,
+      order: s.order,
+      type: s.type,
+      dealCount: s._count?.deals ?? null
+    })),
+    total: stages.length
+  }, null, 2));
+}
+function transformComment(comment) {
+  const parentKey = "actionId" in comment ? "actionId" : "ticketId";
+  const parentId = comment[parentKey];
+  return {
+    id: comment.id,
+    [parentKey]: parentId,
+    authorId: comment.authorId,
+    content: comment.content,
+    author: comment.author,
+    createdAt: new Date(comment.createdAt).toISOString(),
+    updatedAt: new Date(comment.updatedAt).toISOString()
+  };
+}
+function outputCommentJson(comment) {
+  console.log(JSON.stringify(transformComment(comment), null, 2));
+}
+function outputCommentPretty(comment) {
+  const author = comment.author?.name ?? comment.authorId;
+  const when = formatDate(new Date(comment.createdAt));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`${chalk3.bold(author)} ${chalk3.gray(`\u2014 ${when}`)}`);
+  console.log(chalk3.gray(`  ID: ${comment.id}`));
+  console.log();
+  console.log(comment.content);
+  console.log();
+}
+function outputCommentsJson(comments) {
+  console.log(JSON.stringify({
+    comments: comments.map(transformComment),
+    total: comments.length
+  }, null, 2));
+}
+function outputCommentsPretty(comments) {
+  if (comments.length === 0) {
+    console.log(chalk3.gray("No comments."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Comments (${comments.length})`));
+  for (const c of comments) {
+    outputCommentPretty(c);
+  }
+}
+function outputProductJson(product) {
+  console.log(JSON.stringify(transformProduct(product), null, 2));
+}
+function outputProductPretty(product) {
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`
+${chalk3.bold(product.name)} ${chalk3.gray(`(${product.slug})`)}`);
+  console.log(chalk3.gray(`  ID: ${product.id}`));
+  if (product.description) {
+    console.log(`  ${chalk3.gray("Description:")} ${product.description}`);
+  }
+  if (product._count) {
+    const c = product._count;
+    const parts = [
+      c.features != null ? `features: ${c.features}` : null,
+      c.tickets != null ? `tickets: ${c.tickets}` : null
+    ].filter(Boolean);
+    if (parts.length) console.log(`  ${chalk3.cyan("Counts:")} ${parts.join("  ")}`);
+  }
+  console.log();
+}
+function outputProductsJson(products) {
+  console.log(JSON.stringify({
+    products: products.map(transformProduct),
+    total: products.length
+  }, null, 2));
+}
+function outputProductsPretty(products) {
+  if (products.length === 0) {
+    console.log(chalk3.gray("No products found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Products (${products.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const p of products) {
+    const ticketCount = p._count?.tickets != null ? chalk3.gray(` \u2014 ${p._count.tickets} tickets`) : "";
+    console.log(`  ${chalk3.bold(p.name)} ${chalk3.gray(`(${p.slug})`)}${ticketCount}`);
+    console.log(chalk3.gray(`    ID: ${p.id}`));
+  }
+  console.log();
+}
+function transformProduct(product) {
+  return {
+    id: product.id,
+    workspaceId: product.workspaceId,
+    name: product.name,
+    slug: product.slug,
+    description: product.description,
+    icon: product.icon,
+    color: product.color,
+    funTicketIds: product.funTicketIds,
+    ticketCounter: product.ticketCounter,
+    counts: product._count ?? null,
+    createdAt: new Date(product.createdAt).toISOString(),
+    updatedAt: new Date(product.updatedAt).toISOString()
+  };
+}
+function outputFeatureJson(feature) {
+  console.log(JSON.stringify(transformFeature(feature), null, 2));
+}
+function outputFeaturePretty(feature) {
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`
+${chalk3[getFeatureStatusColor(feature.status)](`[${feature.status}]`)} ${chalk3.bold(feature.name)}`);
+  console.log(chalk3.gray(`  ID: ${feature.id}`));
+  if (feature.description) {
+    console.log(`  ${chalk3.gray("Description:")} ${feature.description.substring(0, 120)}${feature.description.length > 120 ? "..." : ""}`);
+  }
+  if (feature.vision) {
+    console.log(`  ${chalk3.gray("Vision:")} ${feature.vision.substring(0, 120)}${feature.vision.length > 120 ? "..." : ""}`);
+  }
+  if (feature.priority != null) {
+    console.log(`  ${chalk3.magenta("Priority:")} ${feature.priority}`);
+  }
+  if (feature._count?.tickets != null) {
+    console.log(`  ${chalk3.cyan("Tickets:")} ${feature._count.tickets}`);
+  }
+  console.log();
+}
+function outputFeaturesJson(features) {
+  console.log(JSON.stringify({
+    features: features.map(transformFeature),
+    total: features.length
+  }, null, 2));
+}
+function outputFeaturesPretty(features) {
+  if (features.length === 0) {
+    console.log(chalk3.gray("No features found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Features (${features.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const f of features) {
+    const statusBadge = chalk3[getFeatureStatusColor(f.status)](`[${f.status}]`);
+    const ticketCount = f._count?.tickets != null ? chalk3.gray(` \u2014 ${f._count.tickets} tickets`) : "";
+    console.log(`  ${statusBadge} ${chalk3.bold(f.name)}${ticketCount}`);
+    console.log(chalk3.gray(`    ID: ${f.id}`));
+  }
+  console.log();
+}
+function transformFeature(feature) {
+  return {
+    id: feature.id,
+    productId: feature.productId,
+    name: feature.name,
+    description: feature.description,
+    vision: feature.vision,
+    status: feature.status,
+    effort: feature.effort,
+    priority: feature.priority,
+    goalId: feature.goalId,
+    goal: feature.goal ?? null,
+    counts: feature._count ?? null,
+    createdAt: new Date(feature.createdAt).toISOString(),
+    updatedAt: new Date(feature.updatedAt).toISOString()
+  };
+}
+function getFeatureStatusColor(status) {
+  switch (status) {
+    case "IDEA":
+      return "gray";
+    case "DEFINED":
+      return "blue";
+    case "IN_PROGRESS":
+      return "yellow";
+    case "SHIPPED":
+      return "green";
+    case "ARCHIVED":
+      return "red";
+    default:
+      return "gray";
+  }
+}
+function outputTicketJson(ticket) {
+  console.log(JSON.stringify(transformTicket(ticket), null, 2));
+}
+function outputTicketPretty(ticket) {
+  const id = ticket.shortId ?? (ticket.number != null ? `#${ticket.number}` : "?");
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(
+    `
+${chalk3[getTicketStatusColor(ticket.status)](`[${ticket.status}]`)} ${chalk3.gray(`[${ticket.type}]`)} ${chalk3.bold(`${id} ${ticket.title}`)}`
+  );
+  console.log(chalk3.gray(`  ID: ${ticket.id}`));
+  if (ticket.isBlocked) {
+    console.log(`  ${chalk3.red("BLOCKED")} by ${ticket.openBlockerCount ?? 0} open ticket(s)`);
+  } else if (ticket.openBlockerCount && ticket.openBlockerCount > 0) {
+    console.log(`  ${chalk3.yellow("Blockers:")} ${ticket.openBlockerCount} open (not currently in flight)`);
+  }
+  if (ticket.feature) {
+    console.log(`  ${chalk3.cyan("Feature:")} ${ticket.feature.name}`);
+  }
+  if (ticket.epic) {
+    console.log(`  ${chalk3.cyan("Epic:")} ${ticket.epic.name}`);
+  }
+  if (ticket.assignee) {
+    console.log(`  ${chalk3.magenta("Assignee:")} ${ticket.assignee.name ?? ticket.assignee.id}`);
+  }
+  if (ticket.priority != null) {
+    console.log(`  ${chalk3.magenta("Priority:")} ${ticket.priority}`);
+  }
+  if (ticket.points != null) {
+    console.log(`  ${chalk3.yellow("Points:")} ${ticket.points}`);
+  }
+  if (ticket.body) {
+    console.log(`  ${chalk3.gray("Body:")} ${ticket.body.substring(0, 200)}${ticket.body.length > 200 ? "..." : ""}`);
+  }
+  const detail = ticket;
+  if (detail.dependsOn && detail.dependsOn.length > 0) {
+    console.log(`  ${chalk3.cyan("Depends on:")}`);
+    for (const dep of detail.dependsOn) {
+      const depId = dep.shortId ?? (dep.number != null ? `#${dep.number}` : "?");
+      console.log(`    - ${chalk3.gray(`[${dep.status}]`)} ${depId} ${dep.title}`);
+    }
+  }
+  if (detail.requiredFor && detail.requiredFor.length > 0) {
+    console.log(`  ${chalk3.cyan("Required for:")}`);
+    for (const dep of detail.requiredFor) {
+      const depId = dep.shortId ?? (dep.number != null ? `#${dep.number}` : "?");
+      console.log(`    - ${chalk3.gray(`[${dep.status}]`)} ${depId} ${dep.title}`);
+    }
+  }
+  if (detail.actions && detail.actions.length > 0) {
+    console.log(`  ${chalk3.cyan("Actions:")} ${detail.actions.length}`);
+    for (const a of detail.actions) {
+      console.log(`    - ${chalk3.gray(`[${a.kanbanStatus ?? a.status}]`)} ${a.name} ${chalk3.gray(`(${a.id})`)}`);
+    }
+  }
+  console.log();
+}
+function outputTicketsJson(tickets) {
+  console.log(JSON.stringify({
+    tickets: tickets.map(transformTicket),
+    total: tickets.length
+  }, null, 2));
+}
+function outputTicketsPretty(tickets) {
+  if (tickets.length === 0) {
+    console.log(chalk3.gray("No tickets found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Tickets (${tickets.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const t of tickets) {
+    const id = t.shortId ?? (t.number != null ? `#${t.number}` : "?");
+    const statusBadge = chalk3[getTicketStatusColor(t.status)](`[${t.status}]`);
+    const typeBadge = chalk3.gray(`[${t.type}]`);
+    const blocked = t.isBlocked ? chalk3.red(" BLOCKED") : "";
+    console.log(`  ${statusBadge} ${typeBadge} ${chalk3.bold(id)} ${t.title}${blocked}`);
+    console.log(chalk3.gray(`    ID: ${t.id}`));
+  }
+  console.log();
+}
+function transformTicket(ticket) {
+  const detail = ticket;
+  return {
+    id: ticket.id,
+    productId: ticket.productId,
+    number: ticket.number,
+    shortId: ticket.shortId,
+    title: ticket.title,
+    body: ticket.body,
+    type: ticket.type,
+    status: ticket.status,
+    priority: ticket.priority,
+    points: ticket.points,
+    branchName: ticket.branchName,
+    prUrl: ticket.prUrl,
+    designUrl: ticket.designUrl,
+    specUrl: ticket.specUrl,
+    links: ticket.links,
+    epicId: ticket.epicId,
+    featureId: ticket.featureId,
+    cycleId: ticket.cycleId,
+    scopeId: ticket.scopeId,
+    assigneeId: ticket.assigneeId,
+    assignee: ticket.assignee ?? null,
+    feature: ticket.feature ?? null,
+    epic: ticket.epic ?? null,
+    openBlockerCount: ticket.openBlockerCount ?? 0,
+    isBlocked: ticket.isBlocked ?? false,
+    counts: ticket._count ?? null,
+    dependsOn: detail.dependsOn ?? void 0,
+    requiredFor: detail.requiredFor ?? void 0,
+    actions: detail.actions?.map((a) => ({
+      id: a.id,
+      name: a.name,
+      status: a.status,
+      kanbanStatus: a.kanbanStatus,
+      completedAt: a.completedAt ? new Date(a.completedAt).toISOString() : null
+    })),
+    completedAt: ticket.completedAt ? new Date(ticket.completedAt).toISOString() : null,
+    createdAt: new Date(ticket.createdAt).toISOString(),
+    updatedAt: new Date(ticket.updatedAt).toISOString()
+  };
+}
+function getTicketStatusColor(status) {
+  switch (status) {
+    case "BACKLOG":
+      return "gray";
+    case "NEEDS_REFINEMENT":
+      return "gray";
+    case "READY_TO_PLAN":
+      return "blue";
+    case "COMMITTED":
+      return "blue";
+    case "IN_PROGRESS":
+      return "yellow";
+    case "BLOCKED":
+      return "red";
+    case "QA":
+      return "cyan";
+    case "DONE":
+      return "green";
+    case "DEPLOYED":
+      return "green";
+    case "ARCHIVED":
+      return "gray";
+    default:
+      return "gray";
+  }
+}
+function outputEpicJson(epic) {
+  console.log(JSON.stringify(transformEpic(epic), null, 2));
+}
+function outputEpicPretty(epic) {
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`
+${chalk3[getEpicStatusColor(epic.status)](`[${epic.status}]`)} ${chalk3.bold(epic.name)}`);
+  console.log(chalk3.gray(`  ID: ${epic.id}`));
+  if (epic.description) {
+    console.log(`  ${chalk3.gray("Description:")} ${epic.description.substring(0, 200)}${epic.description.length > 200 ? "..." : ""}`);
+  }
+  console.log(`  ${chalk3.magenta("Priority:")} ${epic.priority}`);
+  if (epic.startDate) {
+    console.log(`  ${chalk3.cyan("Start:")} ${formatDate(new Date(epic.startDate))}`);
+  }
+  if (epic.targetDate) {
+    console.log(`  ${chalk3.cyan("Target:")} ${formatDate(new Date(epic.targetDate))}`);
+  }
+  if (epic.owner) {
+    console.log(`  ${chalk3.gray("Owner:")} ${epic.owner.name ?? epic.owner.email ?? epic.owner.id}`);
+  }
+  if (epic._count) {
+    const c = epic._count;
+    const parts = [
+      c.actions != null ? `actions: ${c.actions}` : null,
+      c.tickets != null ? `tickets: ${c.tickets}` : null
+    ].filter(Boolean);
+    if (parts.length) console.log(`  ${chalk3.cyan("Counts:")} ${parts.join("  ")}`);
+  }
+  console.log();
+}
+function outputEpicsJson(epics) {
+  console.log(JSON.stringify({
+    epics: epics.map(transformEpic),
+    total: epics.length
+  }, null, 2));
+}
+function outputEpicsPretty(epics) {
+  if (epics.length === 0) {
+    console.log(chalk3.gray("No epics found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Epics (${epics.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const e of epics) {
+    const statusBadge = chalk3[getEpicStatusColor(e.status)](`[${e.status}]`);
+    const counts = e._count ? chalk3.gray(
+      ` \u2014 ${e._count.tickets ?? 0} tickets, ${e._count.actions ?? 0} actions`
+    ) : "";
+    console.log(`  ${statusBadge} ${chalk3.bold(e.name)}${counts}`);
+    console.log(chalk3.gray(`    ID: ${e.id}`));
+  }
+  console.log();
+}
+function transformEpic(epic) {
+  return {
+    id: epic.id,
+    workspaceId: epic.workspaceId,
+    name: epic.name,
+    description: epic.description,
+    status: epic.status,
+    priority: epic.priority,
+    startDate: epic.startDate ? new Date(epic.startDate).toISOString() : null,
+    targetDate: epic.targetDate ? new Date(epic.targetDate).toISOString() : null,
+    ownerId: epic.ownerId,
+    owner: epic.owner ?? null,
+    counts: epic._count ?? null,
+    createdAt: new Date(epic.createdAt).toISOString(),
+    updatedAt: new Date(epic.updatedAt).toISOString()
+  };
+}
+function getEpicStatusColor(status) {
+  switch (status) {
+    case "OPEN":
+      return "blue";
+    case "IN_PROGRESS":
+      return "yellow";
+    case "DONE":
+      return "green";
+    case "CANCELLED":
+      return "red";
+    default:
+      return "gray";
+  }
+}
+function outputStagesPretty(stages) {
+  if (stages.length === 0) {
+    console.log(chalk3.gray("No stages found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Pipeline Stages (${stages.length})`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const stage of stages) {
+    const count = stage._count?.deals != null ? chalk3.gray(` (${stage._count.deals} deals)`) : "";
+    console.log(`  ${chalk3.bold(stage.name)}${count} \u2014 ${chalk3.gray(stage.type)}`);
+  }
+  console.log();
+}
 
 // src/commands/actions.ts
+var VALID_PRIORITIES = [
+  "Quick",
+  "Scheduled",
+  "1st Priority",
+  "2nd Priority",
+  "3rd Priority",
+  "4th Priority",
+  "5th Priority",
+  "Errand",
+  "Remember",
+  "Watch",
+  "Someday Maybe"
+];
 function createActionsCommand() {
   const actions = new Command2("actions").description("Manage actions/tasks");
   actions.command("list").description("List all actions").option("--project <id>", "Filter by project ID").option("--status <status>", "Filter by kanban status (BACKLOG, TODO, IN_PROGRESS, IN_REVIEW, DONE)").option("--assignee <id>", "Filter by assignee ID").action(async (options, cmd) => {
@@ -450,39 +1116,1396 @@ function createActionsCommand() {
       handleError(error, useJson);
     }
   });
-  return actions;
-}
-
-// src/commands/projects.ts
-import { Command as Command3 } from "commander";
-function createProjectsCommand() {
-  const projects = new Command3("projects").description("Manage projects");
-  projects.command("list").description("List all projects").option("--workspace <id>", "Filter by workspace ID").option("--include-actions", "Include actions in output").action(async (options, cmd) => {
+  actions.command("update").description("Update an existing action").requiredOption("--id <id>", "Action ID to update").option("-n, --name <name>", "New action name").option("-d, --description <text>", "New description").option("-p, --project <id>", "Move to project ID").option("--priority <priority>", "Priority (Quick, Scheduled, 1st Priority, etc.)").option("--status <status>", "Status (ACTIVE, COMPLETED, CANCELLED)").option("--kanban <status>", "Kanban status (BACKLOG, TODO, IN_PROGRESS, IN_REVIEW, DONE)").option("--due <date>", 'Due date (YYYY-MM-DD or "null" to clear)').action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
     try {
+      if (options.priority && !VALID_PRIORITIES.includes(options.priority)) {
+        throw new Error(`Invalid priority "${options.priority}". Valid values: ${VALID_PRIORITIES.join(", ")}`);
+      }
+      let dueDate;
+      if (options.due === "null") {
+        dueDate = null;
+      } else if (options.due) {
+        dueDate = new Date(options.due);
+        if (isNaN(dueDate.getTime())) {
+          throw new Error("Invalid due date format. Use YYYY-MM-DD");
+        }
+      }
       const client = getClient();
-      const projects2 = await client.projects.list({
-        workspaceId: options.workspace,
-        includeActions: options.includeActions
+      const action = await client.actions.update({
+        id: options.id,
+        name: options.name,
+        description: options.description,
+        projectId: options.project,
+        priority: options.priority,
+        status: options.status,
+        kanbanStatus: options.kanban,
+        dueDate
       });
       if (useJson) {
-        outputProjectsJson(projects2);
+        outputActionJson(action);
       } else {
-        outputProjectsPretty(projects2);
+        console.log("\n\u2713 Action updated successfully");
+        outputActionPretty(action);
       }
     } catch (error) {
       handleError(error, useJson);
     }
   });
-  return projects;
-}
-
-// src/commands/workspaces.ts
-import { Command as Command4 } from "commander";
-import chalk4 from "chalk";
+  actions.command("create").description("Create a new action").requiredOption("-n, --name <name>", "Action name/title").option("-d, --description <text>", "Action description").option("-p, --project <id>", "Project ID to assign the action to").option("--priority <priority>", "Priority (Quick, Scheduled, 1st Priority, etc.)").option("--due <date>", "Due date (YYYY-MM-DD)").option("--effort <minutes>", "Effort estimate in minutes", parseInt).option("--ticket <id>", "Link action to a product ticket (CUID) after creation").option("--epic <id>", "Epic CUID to attach the action to").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      if (options.priority && !VALID_PRIORITIES.includes(options.priority)) {
+        throw new Error(`Invalid priority "${options.priority}". Valid values: ${VALID_PRIORITIES.join(", ")}`);
+      }
+      let dueDate;
+      if (options.due) {
+        dueDate = new Date(options.due);
+        if (isNaN(dueDate.getTime())) {
+          throw new Error("Invalid due date format. Use YYYY-MM-DD");
+        }
+      }
+      const client = getClient();
+      let action = await client.actions.create({
+        name: options.name,
+        description: options.description,
+        projectId: options.project,
+        priority: options.priority,
+        dueDate,
+        effortEstimate: options.effort,
+        epicId: options.epic
+      });
+      if (options.ticket) {
+        action = await client.tickets.linkAction(options.ticket, action.id);
+      }
+      if (useJson) {
+        outputActionJson(action);
+      } else {
+        console.log("\n\u2713 Action created successfully");
+        outputActionPretty(action);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  const comment = new Command2("comment").description("Manage comments on an action");
+  comment.command("list").description("List comments on an action").requiredOption("--id <id>", "Action ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const comments = await client.actionComments.list(options.id);
+      if (useJson) outputCommentsJson(comments);
+      else outputCommentsPretty(comments);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("add").description("Add a comment to an action").requiredOption("--id <id>", "Action ID").requiredOption("-m, --message <text>", "Comment content (markdown supported)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const created = await client.actionComments.add({
+        actionId: options.id,
+        content: options.message
+      });
+      if (useJson) {
+        outputCommentJson(created);
+      } else {
+        console.log("\n\u2713 Comment added");
+        outputCommentPretty(created);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("update").description("Update one of your own comments").requiredOption("--comment-id <id>", "Comment ID").requiredOption("-m, --message <text>", "New comment content").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const updated = await client.actionComments.update({
+        commentId: options.commentId,
+        content: options.message
+      });
+      if (useJson) {
+        outputCommentJson(updated);
+      } else {
+        console.log("\n\u2713 Comment updated");
+        outputCommentPretty(updated);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("delete").description("Delete one of your own comments").requiredOption("--comment-id <id>", "Comment ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.actionComments.delete(options.commentId);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id: options.commentId }, null, 2));
+      } else {
+        console.log("\n\u2713 Comment deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  actions.addCommand(comment);
+  return actions;
+}
+
+// src/commands/contacts.ts
+import { Command as Command3 } from "commander";
+var VALID_INTERACTION_TYPES = [
+  "EMAIL",
+  "TELEGRAM",
+  "PHONE_CALL",
+  "MEETING",
+  "NOTE",
+  "LINKEDIN",
+  "OTHER"
+];
+var VALID_INTERACTION_DIRECTIONS = ["INBOUND", "OUTBOUND"];
+function createContactsCommand() {
+  const contacts = new Command3("contacts").description("Manage CRM contacts");
+  contacts.command("list").description("List contacts").requiredOption("--workspace <id>", "Workspace ID").option("--search <query>", "Search by name or email").option("--tags <tags>", "Filter by tags (comma-separated)").option("--organization <id>", "Filter by organization ID").option("--limit <n>", "Max results to return", parseInt).option("--cursor <cursor>", "Pagination cursor").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const result = await client.contacts.list({
+        workspaceId: options.workspace,
+        search: options.search,
+        tags: options.tags?.split(",").map((t) => t.trim()),
+        organizationId: options.organization,
+        limit: options.limit,
+        cursor: options.cursor
+      });
+      if (useJson) {
+        outputContactsJson(result.contacts, result.nextCursor);
+      } else {
+        outputContactsPretty(result.contacts);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  contacts.command("get").description("Get a contact by ID").argument("<id>", "Contact ID").option("--interactions", "Include interaction history").action(async (id, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const contact = await client.contacts.get(id, {
+        includeInteractions: options.interactions
+      });
+      if (useJson) {
+        outputContactJson(contact);
+      } else {
+        outputContactPretty(contact);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  contacts.command("create").description("Create a new contact").requiredOption("--workspace <id>", "Workspace ID").option("--first-name <name>", "First name").option("--last-name <name>", "Last name").option("--email <email>", "Email address").option("--phone <phone>", "Phone number").option("--linkedin <url>", "LinkedIn URL").option("--telegram <handle>", "Telegram handle").option("--twitter <handle>", "Twitter/X handle").option("--github <handle>", "GitHub username").option("--bluesky <handle>", "Bluesky handle").option("--about <text>", "About / bio").option("--profile-type <type>", "Profile type").option("--skills <skills>", "Skills (comma-separated)").option("--tags <tags>", "Tags (comma-separated)").option("--organization <id>", "Organization ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const contact = await client.contacts.create({
+        workspaceId: options.workspace,
+        firstName: options.firstName,
+        lastName: options.lastName,
+        email: options.email,
+        phone: options.phone,
+        linkedIn: options.linkedin,
+        telegram: options.telegram,
+        twitter: options.twitter,
+        github: options.github,
+        bluesky: options.bluesky,
+        about: options.about,
+        profileType: options.profileType,
+        skills: options.skills?.split(",").map((s) => s.trim()),
+        tags: options.tags?.split(",").map((t) => t.trim()),
+        organizationId: options.organization
+      });
+      if (useJson) {
+        outputContactJson(contact);
+      } else {
+        console.log("\n\u2713 Contact created successfully");
+        outputContactPretty(contact);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  contacts.command("update").description("Update an existing contact").requiredOption("--id <id>", "Contact ID").option("--first-name <name>", "First name").option("--last-name <name>", "Last name").option("--email <email>", 'Email (use "null" to clear)').option("--phone <phone>", 'Phone (use "null" to clear)').option("--linkedin <url>", 'LinkedIn URL (use "null" to clear)').option("--telegram <handle>", 'Telegram handle (use "null" to clear)').option("--twitter <handle>", 'Twitter/X handle (use "null" to clear)').option("--github <handle>", 'GitHub username (use "null" to clear)').option("--bluesky <handle>", 'Bluesky handle (use "null" to clear)').option("--about <text>", "About / bio").option("--profile-type <type>", "Profile type").option("--skills <skills>", "Skills (comma-separated)").option("--tags <tags>", "Tags (comma-separated)").option("--organization <id>", 'Organization ID (use "null" to clear)').action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    const nullable = (v) => v === "null" ? null : v;
+    try {
+      const client = getClient();
+      const contact = await client.contacts.update({
+        id: options.id,
+        firstName: options.firstName,
+        lastName: options.lastName,
+        email: nullable(options.email),
+        phone: nullable(options.phone),
+        linkedIn: nullable(options.linkedin),
+        telegram: nullable(options.telegram),
+        twitter: nullable(options.twitter),
+        github: nullable(options.github),
+        bluesky: nullable(options.bluesky),
+        about: options.about,
+        profileType: options.profileType,
+        skills: options.skills?.split(",").map((s) => s.trim()),
+        tags: options.tags?.split(",").map((t) => t.trim()),
+        organizationId: nullable(options.organization)
+      });
+      if (useJson) {
+        outputContactJson(contact);
+      } else {
+        console.log("\n\u2713 Contact updated successfully");
+        outputContactPretty(contact);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  contacts.command("delete").description("Delete a contact").argument("<id>", "Contact ID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.contacts.delete(id);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id }, null, 2));
+      } else {
+        console.log(`
+\u2713 Contact ${id} deleted`);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  contacts.command("add-interaction").description("Add an interaction to a contact").requiredOption("--contact <id>", "Contact ID").requiredOption("--type <type>", `Interaction type (${VALID_INTERACTION_TYPES.join(", ")})`).requiredOption("--direction <dir>", `Direction (${VALID_INTERACTION_DIRECTIONS.join(", ")})`).option("--subject <text>", "Subject line").option("--notes <text>", "Notes").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      if (!VALID_INTERACTION_TYPES.includes(options.type)) {
+        throw new Error(`Invalid interaction type "${options.type}". Valid: ${VALID_INTERACTION_TYPES.join(", ")}`);
+      }
+      if (!VALID_INTERACTION_DIRECTIONS.includes(options.direction)) {
+        throw new Error(`Invalid direction "${options.direction}". Valid: ${VALID_INTERACTION_DIRECTIONS.join(", ")}`);
+      }
+      const client = getClient();
+      const interaction = await client.contacts.addInteraction({
+        contactId: options.contact,
+        type: options.type,
+        direction: options.direction,
+        subject: options.subject,
+        notes: options.notes
+      });
+      if (useJson) {
+        outputInteractionJson(interaction);
+      } else {
+        console.log("\n\u2713 Interaction added");
+        outputInteractionPretty(interaction);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return contacts;
+}
+
+// src/commands/deals.ts
+import { Command as Command4 } from "commander";
+function createDealsCommand() {
+  const deals = new Command4("deals").description("Manage pipeline deals");
+  deals.command("pipeline").description("Get pipeline overview with stages").requiredOption("--workspace <id>", "Workspace ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const pipeline = await client.pipelines.get(options.workspace);
+      if (!pipeline) {
+        if (useJson) {
+          console.log(JSON.stringify({ pipeline: null }, null, 2));
+        } else {
+          console.log("No pipeline found for this workspace. One will be created when you add your first deal.");
+        }
+        return;
+      }
+      if (useJson) {
+        outputPipelineJson(pipeline);
+      } else {
+        outputPipelinePretty(pipeline);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  deals.command("stages").description("List pipeline stages").requiredOption("--workspace <id>", "Workspace ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const stages = await client.pipelines.getStages(options.workspace);
+      if (useJson) {
+        outputStagesJson(stages);
+      } else {
+        outputStagesPretty(stages);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  deals.command("list").description("List all deals").requiredOption("--workspace <id>", "Workspace ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const dealsList = await client.pipelines.listDeals(options.workspace);
+      if (useJson) {
+        outputDealsJson(dealsList);
+      } else {
+        outputDealsPretty(dealsList);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  deals.command("get").description("Get a deal by ID").argument("<id>", "Deal ID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const deal = await client.pipelines.getDeal(id);
+      if (useJson) {
+        outputDealJson(deal);
+      } else {
+        outputDealPretty(deal);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  deals.command("create").description("Create a new deal").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--stage <id>", "Pipeline stage ID").requiredOption("--title <title>", "Deal title").option("--description <text>", "Deal description").option("--value <amount>", "Deal value", parseFloat).option("--currency <code>", "Currency code (default: USD)").option("--probability <pct>", "Win probability (0-100)", parseInt).option("--close-date <date>", "Expected close date (YYYY-MM-DD)").option("--contact <id>", "Contact ID").option("--organization <id>", "Organization ID").option("--assigned-to <id>", "Assigned user ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      let expectedCloseDate;
+      if (options.closeDate) {
+        expectedCloseDate = new Date(options.closeDate);
+        if (isNaN(expectedCloseDate.getTime())) {
+          throw new Error("Invalid close date format. Use YYYY-MM-DD");
+        }
+      }
+      const client = getClient();
+      const deal = await client.pipelines.createDeal({
+        workspaceId: options.workspace,
+        stageId: options.stage,
+        title: options.title,
+        description: options.description,
+        value: options.value,
+        currency: options.currency,
+        probability: options.probability,
+        expectedCloseDate,
+        contactId: options.contact,
+        organizationId: options.organization,
+        assignedToId: options.assignedTo
+      });
+      if (useJson) {
+        outputDealJson(deal);
+      } else {
+        console.log("\n\u2713 Deal created successfully");
+        outputDealPretty(deal);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  deals.command("update").description("Update an existing deal").requiredOption("--id <id>", "Deal ID").option("--title <title>", "Deal title").option("--description <text>", 'Description (use "null" to clear)').option("--value <amount>", 'Deal value (use "null" to clear)').option("--currency <code>", "Currency code").option("--probability <pct>", 'Win probability (use "null" to clear)').option("--close-date <date>", 'Expected close date (YYYY-MM-DD or "null" to clear)').option("--contact <id>", 'Contact ID (use "null" to clear)').option("--organization <id>", 'Organization ID (use "null" to clear)').option("--assigned-to <id>", 'Assigned user ID (use "null" to clear)').action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    const nullable = (v, parse) => {
+      if (v === void 0) return void 0;
+      if (v === "null") return null;
+      return parse ? parse(v) : v;
+    };
+    try {
+      let expectedCloseDate;
+      if (options.closeDate === "null") {
+        expectedCloseDate = null;
+      } else if (options.closeDate) {
+        expectedCloseDate = new Date(options.closeDate);
+        if (isNaN(expectedCloseDate.getTime())) {
+          throw new Error("Invalid close date format. Use YYYY-MM-DD");
+        }
+      }
+      const client = getClient();
+      const deal = await client.pipelines.updateDeal({
+        id: options.id,
+        title: options.title,
+        description: nullable(options.description),
+        value: nullable(options.value, parseFloat),
+        currency: options.currency,
+        probability: nullable(options.probability, parseInt),
+        expectedCloseDate,
+        contactId: nullable(options.contact),
+        organizationId: nullable(options.organization),
+        assignedToId: nullable(options.assignedTo)
+      });
+      if (useJson) {
+        outputDealJson(deal);
+      } else {
+        console.log("\n\u2713 Deal updated successfully");
+        outputDealPretty(deal);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  deals.command("move").description("Move a deal to a different stage").requiredOption("--id <id>", "Deal ID").requiredOption("--stage <id>", "Target stage ID").option("--order <n>", "Position within stage", parseInt, 0).action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const deal = await client.pipelines.moveDeal({
+        id: options.id,
+        stageId: options.stage,
+        stageOrder: options.order
+      });
+      if (useJson) {
+        outputDealJson(deal);
+      } else {
+        console.log("\n\u2713 Deal moved successfully");
+        outputDealPretty(deal);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  deals.command("delete").description("Delete a deal").argument("<id>", "Deal ID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.pipelines.deleteDeal(id);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id }, null, 2));
+      } else {
+        console.log(`
+\u2713 Deal ${id} deleted`);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return deals;
+}
+
+// src/commands/epics.ts
+import { Command as Command5 } from "commander";
+
+// src/utils/resolve.ts
+async function resolveWorkspaceId(client, slugOrId) {
+  const config = getConfig();
+  const candidate = slugOrId ?? config.defaultWorkspaceSlug ?? config.defaultWorkspaceId;
+  if (!candidate) {
+    throw new Error(
+      "No workspace specified and no default workspace set. Pass --workspace <slug> or run `exponential workspaces set-default <slug>`."
+    );
+  }
+  const workspaces = await client.workspaces.list();
+  const byId = workspaces.find((w) => w.id === candidate);
+  if (byId) return byId.id;
+  const bySlug = workspaces.find((w) => w.slug === candidate);
+  if (bySlug) return bySlug.id;
+  const known = workspaces.map((w) => w.slug).join(", ");
+  throw new Error(
+    `Workspace "${candidate}" not found. Available: ${known || "(none)"}`
+  );
+}
+async function resolveProductId(client, workspaceId, slugOrId) {
+  const product = await client.products.resolve(workspaceId, slugOrId);
+  return product.id;
+}
+
+// src/commands/epics.ts
+var EPIC_STATUSES = ["OPEN", "IN_PROGRESS", "DONE", "CANCELLED"];
+var EPIC_PRIORITIES = ["HIGH", "MEDIUM", "LOW", "NONE"];
+function validateEpicStatus(value) {
+  if (!value) return void 0;
+  if (!EPIC_STATUSES.includes(value)) {
+    throw new Error(`Invalid epic status "${value}". Valid: ${EPIC_STATUSES.join(", ")}`);
+  }
+  return value;
+}
+function validateEpicPriority(value) {
+  if (!value) return void 0;
+  if (!EPIC_PRIORITIES.includes(value)) {
+    throw new Error(
+      `Invalid epic priority "${value}". Valid: ${EPIC_PRIORITIES.join(", ")}`
+    );
+  }
+  return value;
+}
+function parseDate(value) {
+  if (!value) return void 0;
+  const d = new Date(value);
+  if (isNaN(d.getTime())) {
+    throw new Error(`Invalid date "${value}". Use YYYY-MM-DD`);
+  }
+  return d;
+}
+function createEpicsCommand() {
+  const epics = new Command5("epics").description(
+    "Manage epics. Epics are workspace-scoped and group actions and tickets across products."
+  );
+  epics.command("list").description("List epics in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID").option("--status <status>", `Filter by status: ${EPIC_STATUSES.join(", ")}`).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateEpicStatus(options.status);
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const list = await client.epics.list({ workspaceId, status });
+        if (useJson) outputEpicsJson(list);
+        else outputEpicsPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  epics.command("get <id>").description("Get an epic by CUID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const epic = await client.epics.get(id);
+      if (useJson) outputEpicJson(epic);
+      else outputEpicPretty(epic);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  epics.command("create").description("Create a new epic in a workspace").requiredOption("-n, --name <name>", "Epic name").option("-d, --description <text>", "Description").option("--priority <priority>", `Priority: ${EPIC_PRIORITIES.join(", ")}`).option("--start <date>", "Start date (YYYY-MM-DD)").option("--target <date>", "Target date (YYYY-MM-DD)").option("--workspace <slug|id>", "Workspace slug or CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const priority = validateEpicPriority(options.priority);
+        const startDate = parseDate(options.start);
+        const targetDate = parseDate(options.target);
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const epic = await client.epics.create({
+          workspaceId,
+          name: options.name,
+          description: options.description,
+          priority,
+          startDate,
+          targetDate
+        });
+        if (useJson) outputEpicJson(epic);
+        else {
+          console.log("\n\u2713 Epic created");
+          outputEpicPretty(epic);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  epics.command("update").description("Update an existing epic").requiredOption("--id <id>", "Epic CUID").option("-n, --name <name>", "New name").option("-d, --description <text>", 'New description (or "null" to clear)').option("--status <status>", `Status: ${EPIC_STATUSES.join(", ")}`).option("--priority <priority>", `Priority: ${EPIC_PRIORITIES.join(", ")}`).option("--start <date>", 'Start date (YYYY-MM-DD or "null")').option("--target <date>", 'Target date (YYYY-MM-DD or "null")').action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const parseNullableDate = (v) => {
+          if (v === void 0) return void 0;
+          if (v === "null") return null;
+          const d = new Date(v);
+          if (isNaN(d.getTime())) {
+            throw new Error(`Invalid date "${v}". Use YYYY-MM-DD`);
+          }
+          return d;
+        };
+        const description = options.description === "null" ? null : options.description;
+        const status = validateEpicStatus(options.status);
+        const priority = validateEpicPriority(options.priority);
+        const client = getClient();
+        const epic = await client.epics.update({
+          id: options.id,
+          name: options.name,
+          description,
+          status,
+          priority,
+          startDate: parseNullableDate(options.start),
+          targetDate: parseNullableDate(options.target)
+        });
+        if (useJson) outputEpicJson(epic);
+        else {
+          console.log("\n\u2713 Epic updated");
+          outputEpicPretty(epic);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  return epics;
+}
+
+// src/commands/features.ts
+import { Command as Command6 } from "commander";
+var FEATURE_STATUSES = [
+  "IDEA",
+  "DEFINED",
+  "IN_PROGRESS",
+  "SHIPPED",
+  "ARCHIVED"
+];
+function validateFeatureStatus(value) {
+  if (!value) return void 0;
+  if (!FEATURE_STATUSES.includes(value)) {
+    throw new Error(
+      `Invalid status "${value}". Valid: ${FEATURE_STATUSES.join(", ")}`
+    );
+  }
+  return value;
+}
+function createFeaturesCommand() {
+  const features = new Command6("features").description(
+    "Manage features. A feature lives under a product and groups user stories, scopes, and tickets."
+  );
+  features.command("list").description("List features in a product").requiredOption("--product <slug|id>", "Product slug or CUID").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").option("--status <status>", `Filter by status: ${FEATURE_STATUSES.join(", ")}`).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateFeatureStatus(options.status);
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = await resolveProductId(
+          client,
+          workspaceId,
+          options.product
+        );
+        const list = await client.features.list({ productId, status });
+        if (useJson) outputFeaturesJson(list);
+        else outputFeaturesPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  features.command("get <id>").description("Get a feature by CUID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const feature = await client.features.get(id);
+      if (useJson) outputFeatureJson(feature);
+      else outputFeaturePretty(feature);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  features.command("create").description("Create a new feature in a product").requiredOption("--product <slug|id>", "Product slug or CUID").requiredOption("-n, --name <name>", "Feature name").option("-d, --description <text>", "Description (markdown supported)").option("--vision <text>", "Vision / target outcome").option("--status <status>", `Status: ${FEATURE_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4 (lower = higher)", parseInt).option("--effort <n>", "Effort estimate", parseFloat).option("--workspace <slug|id>", "Workspace (required when --product is a slug)").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateFeatureStatus(options.status);
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = await resolveProductId(
+          client,
+          workspaceId,
+          options.product
+        );
+        const feature = await client.features.create({
+          productId,
+          name: options.name,
+          description: options.description,
+          vision: options.vision,
+          status,
+          priority: options.priority,
+          effort: options.effort
+        });
+        if (useJson) outputFeatureJson(feature);
+        else {
+          console.log("\n\u2713 Feature created");
+          outputFeaturePretty(feature);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  features.command("update").description("Update an existing feature").requiredOption("--id <id>", "Feature CUID").option("-n, --name <name>", "New name").option("-d, --description <text>", "New description").option("--vision <text>", "New vision text").option("--status <status>", `Status: ${FEATURE_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4", parseInt).option("--effort <n>", "Effort estimate", parseFloat).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateFeatureStatus(options.status);
+        const client = getClient();
+        const feature = await client.features.update({
+          id: options.id,
+          name: options.name,
+          description: options.description,
+          vision: options.vision,
+          status,
+          priority: options.priority,
+          effort: options.effort
+        });
+        if (useJson) outputFeatureJson(feature);
+        else {
+          console.log("\n\u2713 Feature updated");
+          outputFeaturePretty(feature);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  return features;
+}
+
+// src/commands/labels.ts
+import { Command as Command7 } from "commander";
+import chalk4 from "chalk";
+var TRIAGE_LABELS = [
+  { slug: "needs-triage", name: "needs-triage", color: "avatar-orange" },
+  { slug: "needs-info", name: "needs-info", color: "avatar-yellow" },
+  { slug: "ready-for-agent", name: "ready-for-agent", color: "avatar-green" },
+  { slug: "ready-for-human", name: "ready-for-human", color: "avatar-lightBlue" },
+  { slug: "wontfix", name: "wontfix", color: "avatar-lightGray" }
+];
+var CUID_PATTERN = /^c[a-z0-9]{20,}$/i;
+function looksLikeCuid(value) {
+  return CUID_PATTERN.test(value);
+}
+function outputTagsPretty(tags) {
+  if (tags.length === 0) {
+    console.log(chalk4.dim("No labels found."));
+    return;
+  }
+  console.log();
+  for (const tag of tags) {
+    const scope = tag.workspaceId === null ? chalk4.cyan("global") : chalk4.magenta("workspace");
+    const category = tag.category === null ? chalk4.dim("(label)") : chalk4.dim(`(${tag.category})`);
+    console.log(
+      `  ${chalk4.bold(tag.slug)}  ${tag.name}  ${chalk4.gray(tag.color)}  ${scope}  ${category}`
+    );
+  }
+  console.log();
+}
+function outputTagPretty(tag, prefix) {
+  if (prefix) console.log(prefix);
+  console.log(`  ${chalk4.bold(tag.slug)}  ${tag.name}  ${chalk4.gray(tag.color)}`);
+}
+async function resolveLabelIds(client, workspaceId, values) {
+  if (values.length === 0) return [];
+  const bySlug = values.filter((v) => !looksLikeCuid(v));
+  const byId = values.filter((v) => looksLikeCuid(v));
+  if (bySlug.length === 0) return byId;
+  const list = await client.labels.list({ workspaceId });
+  const slugMap = new Map(list.allTags.map((t) => [t.slug, t.id]));
+  const resolvedFromSlugs = [];
+  const missing = [];
+  for (const slug of bySlug) {
+    const id = slugMap.get(slug);
+    if (id === void 0) missing.push(slug);
+    else resolvedFromSlugs.push(id);
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Unknown label slug(s): ${missing.join(", ")}. Run \`exponential labels list --workspace <slug>\` to see available labels.`
+    );
+  }
+  return [...byId, ...resolvedFromSlugs];
+}
+function createLabelsCommand() {
+  const labels = new Command7("labels").description(
+    "Manage labels (orthogonal tags applied to actions, tickets, features, and epics)."
+  );
+  labels.command("list").description("List labels visible in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID").option(
+    "--category <category>",
+    'Filter by category. Use "label" for general labels, "null" for category-less labels, or omit to list all.'
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const category = options.category === void 0 ? void 0 : options.category === "null" ? null : options.category;
+        const result = await client.labels.list({ workspaceId, category });
+        if (useJson) {
+          console.log(JSON.stringify(result.allTags, null, 2));
+        } else {
+          outputTagsPretty(result.allTags);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  labels.command("create").description("Create a workspace-scoped label").requiredOption("-n, --name <name>", "Label name").requiredOption("--color <token>", "Color token (e.g. avatar-green, brand-primary)").option("-d, --description <text>", "Description").option("--category <category>", 'Category. Omit (or pass "null") to create a general label.').option("--workspace <slug|id>", "Workspace slug or CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        if (workspaceId === void 0) {
+          throw new Error(
+            "Workspace is required. Pass --workspace <slug|id> or set a default with `exponential workspaces set-default`."
+          );
+        }
+        const category = options.category === void 0 ? void 0 : options.category === "null" ? null : options.category;
+        const tag = await client.labels.create({
+          workspaceId,
+          name: options.name,
+          color: options.color,
+          description: options.description,
+          category
+        });
+        if (useJson) {
+          console.log(JSON.stringify(tag, null, 2));
+        } else {
+          outputTagPretty(tag, chalk4.green("\n\u2713 Label created"));
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  labels.command("seed-triage").description("Idempotently seed the five canonical triage labels into a workspace.").option("--workspace <slug|id>", "Workspace slug or CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        if (workspaceId === void 0) {
+          throw new Error(
+            "Workspace is required. Pass --workspace <slug|id> or set a default with `exponential workspaces set-default`."
+          );
+        }
+        const existing = await client.labels.list({ workspaceId });
+        const existingSlugs = new Set(existing.allTags.map((t) => t.slug));
+        const results = [];
+        for (const def of TRIAGE_LABELS) {
+          if (existingSlugs.has(def.slug)) {
+            results.push({ slug: def.slug, status: "existed" });
+            continue;
+          }
+          const tag = await client.labels.create({
+            workspaceId,
+            name: def.name,
+            color: def.color
+          });
+          results.push({ slug: def.slug, status: "created", tag });
+        }
+        if (useJson) {
+          console.log(JSON.stringify(results, null, 2));
+        } else {
+          console.log();
+          console.log(chalk4.bold("Triage labels:"));
+          for (const r of results) {
+            const tag = chalk4.bold(r.slug);
+            const status = r.status === "created" ? chalk4.green("created") : chalk4.dim("existed");
+            console.log(`  ${tag}  ${status}`);
+          }
+          console.log();
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  return labels;
+}
+
+// src/commands/products.ts
+import { Command as Command8 } from "commander";
+function createProductsCommand() {
+  const products = new Command8("products").description(
+    "Manage products. A workspace contains products; a product holds features and tickets."
+  );
+  products.command("list").description("List products in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID (defaults to configured workspace)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const workspaceId = await resolveWorkspaceId(client, options.workspace);
+      const list = await client.products.list(workspaceId);
+      if (useJson) outputProductsJson(list);
+      else outputProductsPretty(list);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  products.command("get <slugOrId>").description("Get a product by slug or CUID").option("--workspace <slug|id>", "Workspace (required when using a slug)").action(async (slugOrId, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const workspaceId = await resolveWorkspaceId(client, options.workspace);
+      const product = await client.products.resolve(workspaceId, slugOrId);
+      if (useJson) outputProductJson(product);
+      else outputProductPretty(product);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  products.command("create").description("Create a new product").requiredOption("-n, --name <name>", "Product name").requiredOption("--slug <slug>", "Kebab-case slug (matches /^[a-z0-9-]+$/)").option("-d, --description <text>", "Description").option("--icon <icon>", "Icon shortcode").option("--color <color>", "Color").option("--workspace <slug|id>", "Workspace slug or CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        if (!/^[a-z0-9-]+$/.test(options.slug)) {
+          throw new Error(
+            `Invalid slug "${options.slug}". Slug must be kebab-case (a-z, 0-9, -).`
+          );
+        }
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const product = await client.products.create({
+          workspaceId,
+          name: options.name,
+          slug: options.slug,
+          description: options.description,
+          icon: options.icon,
+          color: options.color
+        });
+        if (useJson) outputProductJson(product);
+        else {
+          console.log("\n\u2713 Product created");
+          outputProductPretty(product);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  return products;
+}
+
+// src/commands/projects.ts
+import { Command as Command9 } from "commander";
+function createProjectsCommand() {
+  const projects = new Command9("projects").description("Manage projects");
+  projects.command("list").description("List all projects").option("--workspace <id>", "Filter by workspace ID").option("--include-actions", "Include actions in output").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const projects2 = await client.projects.list({
+        workspaceId: options.workspace,
+        includeActions: options.includeActions
+      });
+      if (useJson) {
+        outputProjectsJson(projects2);
+      } else {
+        outputProjectsPretty(projects2);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return projects;
+}
+
+// src/commands/tickets.ts
+import { Command as Command10 } from "commander";
+function collectRepeatable(value, previous) {
+  return [...previous, value];
+}
+var TICKET_STATUSES = [
+  "BACKLOG",
+  "NEEDS_REFINEMENT",
+  "READY_TO_PLAN",
+  "COMMITTED",
+  "IN_PROGRESS",
+  "BLOCKED",
+  "QA",
+  "DONE",
+  "DEPLOYED",
+  "ARCHIVED"
+];
+var TICKET_TYPES = [
+  "BUG",
+  "FEATURE",
+  "CHORE",
+  "IMPROVEMENT",
+  "SPIKE",
+  "RESEARCH"
+];
+function validateTicketStatus(value) {
+  if (!value) return void 0;
+  if (!TICKET_STATUSES.includes(value)) {
+    throw new Error(
+      `Invalid ticket status "${value}". Valid: ${TICKET_STATUSES.join(", ")}`
+    );
+  }
+  return value;
+}
+function validateTicketType(value) {
+  if (!value) return void 0;
+  if (!TICKET_TYPES.includes(value)) {
+    throw new Error(
+      `Invalid ticket type "${value}". Valid: ${TICKET_TYPES.join(", ")}`
+    );
+  }
+  return value;
+}
+function createTicketsCommand() {
+  const tickets = new Command10("tickets").description(
+    "Manage product backlog tickets. Tickets live under a product, link to features/epics, depend on each other, and can be implemented via actions."
+  );
+  tickets.command("list").description("List tickets in a product").requiredOption("--product <slug|id>", "Product slug or CUID").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").option("--status <status>", `Filter by status: ${TICKET_STATUSES.join(", ")}`).option("--type <type>", `Filter by type: ${TICKET_TYPES.join(", ")}`).option("--feature <id>", "Filter by feature CUID").option("--epic <id>", "Filter by epic CUID").option("--assignee <id>", "Filter by assignee user ID").option(
+    "--label <slug-or-id>",
+    "Filter to tickets carrying this label (repeatable; AND semantics)",
+    collectRepeatable,
+    []
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateTicketStatus(options.status);
+        const type = validateTicketType(options.type);
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = await resolveProductId(
+          client,
+          workspaceId,
+          options.product
+        );
+        const list = await client.tickets.list({
+          productId,
+          status,
+          type,
+          featureId: options.feature,
+          epicId: options.epic,
+          assigneeId: options.assignee
+        });
+        let filtered = list;
+        if (options.label.length > 0) {
+          const labelIds = new Set(
+            await resolveLabelIds(client, workspaceId, options.label)
+          );
+          const ticketLabelSets = await Promise.all(
+            list.map(
+              (t) => client.labels.listForEntity({ entityType: "ticket", entityId: t.id }).then((tags) => new Set(tags.map((tag) => tag.id)))
+            )
+          );
+          filtered = list.filter((_t, idx) => {
+            const tagSet = ticketLabelSets[idx];
+            if (tagSet === void 0) return false;
+            for (const id of labelIds) {
+              if (!tagSet.has(id)) return false;
+            }
+            return true;
+          });
+        }
+        if (useJson) outputTicketsJson(filtered);
+        else outputTicketsPretty(filtered);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  tickets.command("get <id>").description("Show a ticket with dependencies, actions, and comments").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const ticket = await client.tickets.get(id);
+      if (useJson) outputTicketJson(ticket);
+      else outputTicketPretty(ticket);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  tickets.command("show <id>").description("Alias for `tickets get`").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const ticket = await client.tickets.get(id);
+      if (useJson) outputTicketJson(ticket);
+      else outputTicketPretty(ticket);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  tickets.command("create").description("Create a new ticket in a product").requiredOption("--product <slug|id>", "Product slug or CUID").requiredOption("-t, --title <title>", "Ticket title").option("-b, --body <text>", "Body (markdown supported)").option("--type <type>", `Ticket type: ${TICKET_TYPES.join(", ")}`).option("--status <status>", `Initial status: ${TICKET_STATUSES.join(", ")}`).option("--priority <n>", "Priority 0-4 (lower = higher)", parseInt).option("--points <n>", "Story points", parseFloat).option("--feature <id>", "Feature CUID to attach to").option("--epic <id>", "Epic CUID to attach to").option("--assignee <id>", "Assignee user ID").option("--branch <name>", "Branch name").option("--pr <url>", "Pull request URL").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").option(
+    "--label <slug-or-id>",
+    "Label to attach (repeatable)",
+    collectRepeatable,
+    []
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateTicketStatus(options.status);
+        const type = validateTicketType(options.type);
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = await resolveProductId(
+          client,
+          workspaceId,
+          options.product
+        );
+        const ticket = await client.tickets.create({
+          productId,
+          title: options.title,
+          body: options.body,
+          type,
+          status,
+          priority: options.priority,
+          points: options.points,
+          featureId: options.feature,
+          epicId: options.epic,
+          assigneeId: options.assignee,
+          branchName: options.branch,
+          prUrl: options.pr
+        });
+        if (options.label.length > 0) {
+          const tagIds = await resolveLabelIds(client, workspaceId, options.label);
+          await client.labels.setEntityTags({
+            entityType: "ticket",
+            entityId: ticket.id,
+            tagIds
+          });
+        }
+        if (useJson) outputTicketJson(ticket);
+        else {
+          console.log("\n\u2713 Ticket created");
+          outputTicketPretty(ticket);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  tickets.command("update").description("Update an existing ticket").requiredOption("--id <id>", "Ticket CUID").option("-t, --title <title>", "New title").option("-b, --body <text>", "New body").option("--type <type>", `Type: ${TICKET_TYPES.join(", ")}`).option("--status <status>", `Status: ${TICKET_STATUSES.join(", ")}`).option("--priority <n>", 'Priority 0-4 (or "null" to clear)').option("--points <n>", 'Story points (or "null" to clear)').option("--feature <id>", 'Feature CUID (or "null" to detach)').option("--epic <id>", 'Epic CUID (or "null" to detach)').option("--assignee <id>", 'Assignee user ID (or "null" to unassign)').option("--branch <name>", 'Branch name (or "null")').option("--pr <url>", 'PR URL (or "null")').option(
+    "--add-label <slug-or-id>",
+    "Label to attach to this ticket (repeatable)",
+    collectRepeatable,
+    []
+  ).option(
+    "--remove-label <slug-or-id>",
+    "Label to detach from this ticket (repeatable)",
+    collectRepeatable,
+    []
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const parseNullableInt = (v) => {
+          if (v === void 0) return void 0;
+          if (v === "null") return null;
+          const n = parseInt(v, 10);
+          if (isNaN(n)) throw new Error(`Invalid number: ${v}`);
+          return n;
+        };
+        const parseNullableFloat = (v) => {
+          if (v === void 0) return void 0;
+          if (v === "null") return null;
+          const n = parseFloat(v);
+          if (isNaN(n)) throw new Error(`Invalid number: ${v}`);
+          return n;
+        };
+        const parseNullableString = (v) => {
+          if (v === void 0) return void 0;
+          if (v === "null") return null;
+          return v;
+        };
+        const status = validateTicketStatus(options.status);
+        const type = validateTicketType(options.type);
+        const client = getClient();
+        const ticket = await client.tickets.update({
+          id: options.id,
+          title: options.title,
+          body: options.body,
+          type,
+          status,
+          priority: parseNullableInt(options.priority),
+          points: parseNullableFloat(options.points),
+          featureId: parseNullableString(options.feature),
+          epicId: parseNullableString(options.epic),
+          assigneeId: parseNullableString(options.assignee),
+          branchName: parseNullableString(options.branch),
+          prUrl: parseNullableString(options.pr)
+        });
+        if (options.addLabel.length > 0 || options.removeLabel.length > 0) {
+          const current = await client.labels.listForEntity({
+            entityType: "ticket",
+            entityId: options.id
+          });
+          const currentIds = new Set(current.map((t) => t.id));
+          const addIds = await resolveLabelIds(client, void 0, options.addLabel);
+          const removeIds = await resolveLabelIds(client, void 0, options.removeLabel);
+          for (const id of addIds) currentIds.add(id);
+          for (const id of removeIds) currentIds.delete(id);
+          await client.labels.setEntityTags({
+            entityType: "ticket",
+            entityId: options.id,
+            tagIds: [...currentIds]
+          });
+        }
+        if (useJson) outputTicketJson(ticket);
+        else {
+          console.log("\n\u2713 Ticket updated");
+          outputTicketPretty(ticket);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  tickets.command("delete <id>").description("Delete a ticket").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.tickets.delete(id);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id }, null, 2));
+      } else {
+        console.log("\n\u2713 Ticket deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  tickets.command("block <ticket>").description("Mark <ticket> as blocked by another ticket").requiredOption("--by <id>", "Ticket CUID that must complete first").action(
+    async (ticket, options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const dep = await client.tickets.addDependency(ticket, options.by);
+        if (useJson) {
+          console.log(JSON.stringify(dep, null, 2));
+        } else {
+          const depId = dep.dependsOn.shortId ?? (dep.dependsOn.number != null ? `#${dep.dependsOn.number}` : dep.dependsOn.id);
+          console.log(`
+\u2713 Ticket ${ticket} now depends on ${depId} ${dep.dependsOn.title}`);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  tickets.command("unblock <ticket>").description("Remove a blocking dependency from <ticket>").requiredOption("--by <id>", "The ticket CUID that was blocking").action(
+    async (ticket, options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        await client.tickets.removeDependency(ticket, options.by);
+        if (useJson) {
+          console.log(JSON.stringify({ ticketId: ticket, removedBlocker: options.by }, null, 2));
+        } else {
+          console.log(`
+\u2713 Dependency removed: ${ticket} no longer blocked by ${options.by}`);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  tickets.command("link-action").description("Attach an existing action to a ticket").requiredOption("--id <id>", "Ticket CUID").requiredOption("--action <id>", "Action CUID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const action = await client.tickets.linkAction(options.id, options.action);
+      if (useJson) outputActionJson(action);
+      else {
+        console.log("\n\u2713 Action linked to ticket");
+        outputActionPretty(action);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  tickets.command("unlink-action").description("Detach an action from whatever ticket it is on").requiredOption("--action <id>", "Action CUID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const action = await client.tickets.unlinkAction(options.action);
+      if (useJson) outputActionJson(action);
+      else {
+        console.log("\n\u2713 Action unlinked");
+        outputActionPretty(action);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  const comment = new Command10("comment").description("Manage comments on a ticket");
+  comment.command("add").description("Add a comment to a ticket").requiredOption("--id <id>", "Ticket CUID").requiredOption("-m, --message <text>", "Comment content (markdown supported)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const created = await client.tickets.addComment({
+        ticketId: options.id,
+        content: options.message
+      });
+      if (useJson) outputCommentJson(created);
+      else {
+        console.log("\n\u2713 Comment added");
+        outputCommentPretty(created);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("delete").description("Delete one of your own ticket comments").requiredOption("--comment-id <id>", "Comment ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.tickets.deleteComment(options.commentId);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id: options.commentId }, null, 2));
+      } else {
+        console.log("\n\u2713 Comment deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  tickets.addCommand(comment);
+  return tickets;
+}
+
+// src/commands/workspaces.ts
+import { Command as Command11 } from "commander";
+import chalk5 from "chalk";
 function createWorkspacesCommand() {
-  const workspaces = new Command4("workspaces").description("Manage workspaces");
+  const workspaces = new Command11("workspaces").description("Manage workspaces");
   workspaces.command("list").description("List all workspaces").action(async (_options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -495,7 +2518,7 @@ function createWorkspacesCommand() {
         const config = getConfig();
         outputWorkspacesPretty(workspaces2);
         if (config.defaultWorkspaceSlug) {
-          console.log(chalk4.gray(`Default workspace: ${config.defaultWorkspaceSlug}`));
+          console.log(chalk5.gray(`Default workspace: ${config.defaultWorkspaceSlug}`));
         }
       }
     } catch (error) {
@@ -508,10 +2531,10 @@ function createWorkspacesCommand() {
       const workspaces2 = await client.workspaces.list();
       const workspace = workspaces2.find((w) => w.slug === slug);
       if (!workspace) {
-        console.error(chalk4.red(`Workspace with slug "${slug}" not found.`));
-        console.log(chalk4.gray("Available workspaces:"));
+        console.error(chalk5.red(`Workspace with slug "${slug}" not found.`));
+        console.log(chalk5.gray("Available workspaces:"));
         workspaces2.forEach((w) => {
-          console.log(chalk4.gray(`  - ${w.slug} (${w.name})`));
+          console.log(chalk5.gray(`  - ${w.slug} (${w.name})`));
         });
         process.exit(1);
       }
@@ -519,7 +2542,7 @@ function createWorkspacesCommand() {
         defaultWorkspaceId: workspace.id,
         defaultWorkspaceSlug: workspace.slug
       });
-      console.log(chalk4.green(`Default workspace set to: ${workspace.name} (${workspace.slug})`));
+      console.log(chalk5.green(`Default workspace set to: ${workspace.name} (${workspace.slug})`));
     } catch (error) {
       handleError(error);
     }
@@ -528,11 +2551,26 @@ function createWorkspacesCommand() {
 }
 
 // src/index.ts
-var program = new Command5();
-program.name("exponential").description("CLI to interact with Exponential productivity app").version("1.0.0").option("--json", "Output as JSON (default when piped)").option("--pretty", "Force pretty-printed output");
+var program = new Command12();
+program.name("exponential").description(
+  [
+    "CLI to interact with Exponential productivity app.",
+    "",
+    "Work-tracking hierarchy:",
+    "  workspace -> product -> feature -> ticket -> action",
+    "  epics are workspace-scoped and can group tickets and actions across products."
+  ].join("\n")
+).version("1.0.0").option("--json", "Output as JSON (default when piped)").option("--pretty", "Force pretty-printed output");
 program.addCommand(createAuthCommand());
 program.addCommand(createActionsCommand());
+program.addCommand(createContactsCommand());
+program.addCommand(createDealsCommand());
+program.addCommand(createEpicsCommand());
+program.addCommand(createFeaturesCommand());
+program.addCommand(createLabelsCommand());
+program.addCommand(createProductsCommand());
 program.addCommand(createProjectsCommand());
+program.addCommand(createTicketsCommand());
 program.addCommand(createWorkspacesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map