exponential-cli 1.9.0 → 1.11.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command19 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/commands/auth.ts
 import { Command } from "commander";
@@ -752,30 +752,59 @@ function outputStagesJson(stages) {
     total: stages.length
   }, null, 2));
 }
-function transformComment(comment) {
-  const parentKey = "actionId" in comment ? "actionId" : "ticketId";
-  const parentId = comment[parentKey];
+var COMMENT_PARENT_KEYS = ["actionId", "ticketId", "goalId", "featureId", "pageId"];
+function normalizeComment(comment) {
+  const raw = comment;
+  const parentKey = COMMENT_PARENT_KEYS.find((k) => k in raw) ?? "parentId";
+  const author = raw.author ?? raw.createdBy ?? null;
   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()
+    parentKey,
+    parentId: raw[parentKey],
+    authorId: raw.authorId ?? raw.createdById,
+    author,
+    content: raw.content ?? raw.body ?? "",
+    createdAt: new Date(comment.createdAt),
+    updatedAt: new Date(comment.updatedAt),
+    parentCommentId: raw.parentId ?? null,
+    threadId: raw.threadId ?? null,
+    resolvedAt: raw.resolvedAt ? new Date(raw.resolvedAt) : null
+  };
+}
+function transformComment(comment) {
+  const n = normalizeComment(comment);
+  const out = {
+    id: n.id,
+    [n.parentKey]: n.parentId,
+    authorId: n.authorId,
+    content: n.content,
+    author: n.author,
+    createdAt: n.createdAt.toISOString(),
+    updatedAt: n.updatedAt.toISOString()
   };
+  if (n.threadId !== null) out.threadId = n.threadId;
+  if (n.parentCommentId !== null && n.parentKey !== "parentId") {
+    out.parentCommentId = n.parentCommentId;
+  }
+  if (n.resolvedAt) out.resolvedAt = n.resolvedAt.toISOString();
+  return out;
 }
 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));
+  const n = normalizeComment(comment);
+  const author = n.author?.name ?? n.authorId;
+  const when = formatDate(n.createdAt);
+  const badges = [
+    n.parentCommentId && n.parentKey !== "parentId" ? chalk3.gray("(reply)") : "",
+    n.resolvedAt ? chalk3.green("(resolved)") : ""
+  ].filter(Boolean).join(" ");
   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(`${chalk3.bold(author)} ${chalk3.gray(`\u2014 ${when}`)}${badges ? ` ${badges}` : ""}`);
+  console.log(chalk3.gray(`  ID: ${n.id}`));
   console.log();
-  console.log(comment.content);
+  console.log(n.content);
   console.log();
 }
 function outputCommentsJson(comments) {
@@ -1382,6 +1411,343 @@ Scopes (${scopes.length} total)`));
   }
   console.log();
 }
+function getGoalStatusColor(status) {
+  switch (status) {
+    case "planned":
+      return "blue";
+    case "active":
+      return "yellow";
+    case "completed":
+      return "green";
+    case "archived":
+      return "gray";
+    case "on-hold":
+      return "red";
+    default:
+      return "gray";
+  }
+}
+function getKeyResultStatusColor(status) {
+  switch (status) {
+    case "not-started":
+      return "gray";
+    case "on-track":
+      return "green";
+    case "at-risk":
+      return "yellow";
+    case "off-track":
+      return "red";
+    case "achieved":
+      return "green";
+    default:
+      return "gray";
+  }
+}
+function keyResultProgress(kr) {
+  const range = kr.targetValue - kr.startValue;
+  if (range <= 0) return 0;
+  return Math.max(
+    0,
+    Math.min(100, Math.round((kr.currentValue - kr.startValue) / range * 100))
+  );
+}
+function transformGoal(goal) {
+  return {
+    id: goal.id,
+    title: goal.title,
+    description: goal.description,
+    status: goal.status,
+    period: goal.period,
+    health: goal.healthOverride ?? goal.health,
+    // Effective progress: manual override, else the key-result mean, else null
+    // for "no signal". Undefined (rather than null) means the server predates
+    // the field — report null rather than inventing a 0.
+    progress: goal.resolvedProgress ?? null,
+    isProgressManual: goal.isProgressManual ?? false,
+    dueDate: goal.dueDate ? new Date(goal.dueDate).toISOString() : null,
+    workspaceId: goal.workspaceId,
+    workspace: goal.workspace ? { id: goal.workspace.id, slug: goal.workspace.slug, name: goal.workspace.name } : null,
+    parentGoalId: goal.parentGoalId,
+    driUserId: goal.driUserId,
+    lifeDomain: goal.lifeDomain ? { id: goal.lifeDomain.id, title: goal.lifeDomain.title } : null,
+    // THE JOIN: actions carry a projectId and goals carry projects, so inverting
+    // this map is what ties a day's work back to an objective. Never elided.
+    projects: goal.projects?.map((p) => ({ id: p.id, name: p.name, slug: p.slug ?? null })) ?? [],
+    childGoals: goal.childGoals?.map((c) => ({ id: c.id, title: c.title, status: c.status })) ?? [],
+    keyResultCount: goal._count?.keyResults ?? goal.keyResults?.length ?? null,
+    createdAt: goal.createdAt ? new Date(goal.createdAt).toISOString() : null,
+    updatedAt: goal.updatedAt ? new Date(goal.updatedAt).toISOString() : null
+  };
+}
+function outputGoalJson(goal) {
+  console.log(JSON.stringify(transformGoal(goal), null, 2));
+}
+function outputGoalPretty(goal) {
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  const badge = chalk3[getGoalStatusColor(goal.status)](`[${goal.status}]`);
+  console.log(`
+${badge} ${chalk3.bold(goal.title)} ${chalk3.gray(`#${goal.id}`)}`);
+  if (goal.period) console.log(`  ${chalk3.gray("Period:")} ${goal.period}`);
+  const health = goal.healthOverride ?? goal.health;
+  if (health) console.log(`  ${chalk3.gray("Health:")} ${health}`);
+  if (goal.description) {
+    console.log(`  ${chalk3.gray("Description:")} ${goal.description.substring(0, 200)}${goal.description.length > 200 ? "..." : ""}`);
+  }
+  if (goal.parentGoal) {
+    console.log(`  ${chalk3.gray("Parent:")} ${goal.parentGoal.title} ${chalk3.gray(`#${goal.parentGoal.id}`)}`);
+  }
+  if (goal.projects?.length) {
+    console.log(`  ${chalk3.cyan("Projects:")} ${goal.projects.map((p) => p.name).join(", ")}`);
+  }
+  if (goal.childGoals?.length) {
+    console.log(`  ${chalk3.cyan("Sub-goals:")} ${goal.childGoals.length}`);
+  }
+  console.log();
+}
+function outputGoalsJson(goals) {
+  console.log(JSON.stringify({
+    goals: goals.map(transformGoal),
+    total: goals.length
+  }, null, 2));
+}
+function outputGoalsPretty(goals) {
+  if (goals.length === 0) {
+    console.log(chalk3.gray("No goals found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Goals (${goals.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const g of goals) {
+    const badge = chalk3[getGoalStatusColor(g.status)](`[${g.status}]`);
+    const period = g.period ? chalk3.gray(` ${g.period}`) : "";
+    const krs = g._count?.keyResults ? chalk3.gray(` \u2014 ${g._count.keyResults} KRs`) : "";
+    console.log(`  ${badge}${period} ${chalk3.bold(g.title)}${krs}`);
+    console.log(chalk3.gray(`    ID: ${g.id}`));
+  }
+  console.log();
+}
+function transformGoalTree(node) {
+  return {
+    ...transformGoal(node),
+    keyResults: node.keyResults?.map((kr) => ({
+      id: kr.id,
+      status: kr.status,
+      currentValue: kr.currentValue,
+      targetValue: kr.targetValue
+    })) ?? [],
+    children: node.childGoals?.map(transformGoalTree) ?? []
+  };
+}
+function outputGoalTreeJson(nodes) {
+  console.log(JSON.stringify({
+    goals: nodes.map(transformGoalTree),
+    total: nodes.length
+  }, null, 2));
+}
+function outputGoalTreePretty(nodes) {
+  if (nodes.length === 0) {
+    console.log(chalk3.gray("No goals found."));
+    return;
+  }
+  console.log(chalk3.bold("\nGoal tree"));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  const walk = (node, depth) => {
+    const pad = "  ".repeat(depth + 1);
+    const badge = chalk3[getGoalStatusColor(node.status)](`[${node.status}]`);
+    const period = node.period ? chalk3.gray(` ${node.period}`) : "";
+    const krs = node.keyResults?.length ? chalk3.gray(` \u2014 ${node.keyResults.length} KRs`) : "";
+    console.log(`${pad}${depth > 0 ? "\u2514 " : ""}${badge}${period} ${chalk3.bold(node.title)} ${chalk3.gray(`#${node.id}`)}${krs}`);
+    for (const child of node.childGoals ?? []) {
+      walk(child, depth + 1);
+    }
+  };
+  for (const node of nodes) walk(node, 0);
+  console.log();
+}
+function outputGoalPeriodsJson(periods) {
+  console.log(JSON.stringify({ periods, total: periods.length }, null, 2));
+}
+function outputGoalPeriodsPretty(periods) {
+  console.log(chalk3.bold(`
+Periods (${periods.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const p of periods) {
+    console.log(`  ${chalk3.bold(p.value)} ${chalk3.gray(p.label)}`);
+  }
+  console.log();
+}
+function outputGoalStatsJson(stats) {
+  console.log(JSON.stringify({
+    ...stats,
+    periodEndDate: stats.periodEndDate ? new Date(stats.periodEndDate).toISOString() : null
+  }, null, 2));
+}
+function outputGoalStatsPretty(stats) {
+  console.log(chalk3.bold("\nOKR stats"));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(`  ${chalk3.gray("Objectives:")}  ${stats.totalObjectives}`);
+  console.log(`  ${chalk3.gray("Key results:")} ${stats.totalKeyResults} (${stats.completedKeyResults} achieved)`);
+  console.log(
+    `  ${chalk3.gray("Breakdown:")}   ${chalk3.green(`${stats.statusBreakdown.onTrack} on-track`)}, ${chalk3.yellow(`${stats.statusBreakdown.atRisk} at-risk`)}, ${chalk3.red(`${stats.statusBreakdown.offTrack} off-track`)}, ${chalk3.green(`${stats.statusBreakdown.achieved} achieved`)}`
+  );
+  console.log(`  ${chalk3.gray("Avg progress:")} ${stats.averageProgress}%`);
+  if (stats.averageConfidence != null) {
+    console.log(`  ${chalk3.gray("Avg confidence:")} ${stats.averageConfidence}%`);
+  }
+  if (stats.periodEndDate) {
+    console.log(`  ${chalk3.gray("Period ends:")}  ${new Date(stats.periodEndDate).toISOString().slice(0, 10)}`);
+  }
+  console.log();
+}
+function lastCheckInAt(kr) {
+  if (!kr.checkIns?.length) return null;
+  const latest = kr.checkIns.reduce(
+    (newest, c) => new Date(c.createdAt) > new Date(newest.createdAt) ? c : newest
+  );
+  return new Date(latest.createdAt).toISOString();
+}
+function transformKeyResult(kr) {
+  return {
+    id: kr.id,
+    goalId: kr.goalId,
+    goal: kr.goal ? { id: kr.goal.id, title: kr.goal.title } : null,
+    title: kr.title,
+    description: kr.description,
+    status: kr.statusOverride ?? kr.status,
+    statusOverride: kr.statusOverride ?? null,
+    startValue: kr.startValue,
+    currentValue: kr.currentValue,
+    targetValue: kr.targetValue,
+    progress: keyResultProgress(kr),
+    unit: kr.unit,
+    unitLabel: kr.unitLabel ?? null,
+    period: kr.period,
+    periodEnd: kr.periodEnd ? new Date(kr.periodEnd).toISOString() : null,
+    lastCheckInAt: lastCheckInAt(kr),
+    confidence: kr.confidence ?? null,
+    driUserId: kr.driUserId,
+    workspaceId: kr.workspaceId,
+    projects: kr.projects?.map((l) => ({ id: l.projectId, name: l.project?.name ?? null })) ?? [],
+    features: kr.features?.map((l) => ({ id: l.featureId, name: l.feature?.name ?? null })) ?? [],
+    createdAt: kr.createdAt ? new Date(kr.createdAt).toISOString() : null,
+    updatedAt: kr.updatedAt ? new Date(kr.updatedAt).toISOString() : null
+  };
+}
+function outputKeyResultJson(kr) {
+  console.log(JSON.stringify(transformKeyResult(kr), null, 2));
+}
+function outputKeyResultPretty(kr) {
+  const status = kr.statusOverride ?? kr.status;
+  const badge = chalk3[getKeyResultStatusColor(status)](`[${status}]`);
+  console.log(`  ${badge} ${chalk3.bold(kr.title)}`);
+  console.log(
+    chalk3.gray(
+      `    ${kr.currentValue}/${kr.targetValue} ${kr.unit} (${keyResultProgress(kr)}%)${kr.period ? ` \xB7 ${kr.period}` : ""} \xB7 objective #${kr.goalId}`
+    )
+  );
+  console.log(chalk3.gray(`    ID: ${kr.id}`));
+  if (kr.projects?.length) {
+    console.log(chalk3.gray(`    Projects: ${kr.projects.map((l) => l.project?.name ?? l.projectId).join(", ")}`));
+  }
+  if (kr.features?.length) {
+    console.log(chalk3.gray(`    Features: ${kr.features.map((l) => l.feature?.name ?? l.featureId).join(", ")}`));
+  }
+}
+function outputKeyResultsJson(keyResults) {
+  console.log(JSON.stringify({
+    keyResults: keyResults.map(transformKeyResult),
+    total: keyResults.length
+  }, null, 2));
+}
+function outputKeyResultsPretty(keyResults) {
+  if (keyResults.length === 0) {
+    console.log(chalk3.gray("No key results found."));
+    return;
+  }
+  console.log(chalk3.bold(`
+Key results (${keyResults.length} total)`));
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const kr of keyResults) {
+    outputKeyResultPretty(kr);
+  }
+  console.log();
+}
+function outputCheckInJson(checkIn) {
+  console.log(JSON.stringify({
+    id: checkIn.id,
+    keyResultId: checkIn.keyResultId,
+    previousValue: checkIn.previousValue,
+    newValue: checkIn.newValue,
+    notes: checkIn.notes,
+    createdAt: checkIn.createdAt ? new Date(checkIn.createdAt).toISOString() : null
+  }, null, 2));
+}
+function outputCheckInPretty(checkIn) {
+  console.log(`  ${chalk3.gray("Value:")} ${checkIn.previousValue} \u2192 ${chalk3.bold(String(checkIn.newValue))}`);
+  if (checkIn.notes) console.log(`  ${chalk3.gray("Note:")} ${checkIn.notes}`);
+  console.log(chalk3.gray(`  Check-in ID: ${checkIn.id}`));
+  console.log();
+}
+function transformObjective(objective) {
+  return {
+    id: objective.id,
+    title: objective.title,
+    description: objective.description,
+    status: objective.status,
+    period: objective.period,
+    health: objective.health,
+    progress: objective.progress,
+    statusCounts: objective.statusCounts,
+    workspaceId: objective.workspaceId,
+    workspace: objective.workspace ? {
+      id: objective.workspace.id,
+      slug: objective.workspace.slug,
+      name: objective.workspace.name
+    } : null,
+    parentGoalId: objective.parentGoalId,
+    keyResults: objective.keyResults.map(transformKeyResult)
+  };
+}
+function outputObjectivesJson(objectives) {
+  const totalKeyResults = objectives.reduce((n, o) => n + o.keyResults.length, 0);
+  console.log(JSON.stringify({
+    objectives: objectives.map(transformObjective),
+    total: objectives.length,
+    totalKeyResults
+  }, null, 2));
+}
+function outputObjectivesPretty(objectives) {
+  if (objectives.length === 0) {
+    console.log(chalk3.gray("No OKRs found."));
+    return;
+  }
+  const totalKeyResults = objectives.reduce((n, o) => n + o.keyResults.length, 0);
+  console.log(
+    chalk3.bold(`
+OKRs (${objectives.length} objectives, ${totalKeyResults} key results)`)
+  );
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const o of objectives) {
+    const badge = chalk3[getGoalStatusColor(o.status)](`[${o.status}]`);
+    const period = o.period ? chalk3.gray(` ${o.period}`) : "";
+    console.log(
+      `
+  ${badge}${period} ${chalk3.bold(o.title)} ${chalk3.gray(`#${o.id}`)} ${chalk3.gray(`${o.progress}%`)}`
+    );
+    if (o.keyResults.length === 0) {
+      console.log(chalk3.gray("      (no key results)"));
+      continue;
+    }
+    for (const kr of o.keyResults) {
+      const krStatus = kr.statusOverride ?? kr.status;
+      const krBadge = chalk3[getKeyResultStatusColor(krStatus)](`[${krStatus}]`);
+      console.log(`    ${krBadge} ${kr.title} ${chalk3.gray(`${kr.currentValue}/${kr.targetValue} ${kr.unit}`)}`);
+      console.log(chalk3.gray(`      ID: ${kr.id}`));
+    }
+  }
+  console.log();
+}
 
 // src/commands/actions.ts
 var VALID_PRIORITIES = [
@@ -2085,6 +2451,9 @@ import { Command as Command5 } from "commander";
 
 // src/utils/resolve.ts
 async function resolveWorkspaceId(client, slugOrId) {
+  return (await resolveWorkspace(client, slugOrId)).id;
+}
+async function resolveWorkspace(client, slugOrId) {
   const config = getConfig();
   const candidate = slugOrId ?? config.defaultWorkspaceSlug ?? config.defaultWorkspaceId;
   if (!candidate) {
@@ -2094,9 +2463,9 @@ async function resolveWorkspaceId(client, slugOrId) {
   }
   const workspaces = await client.workspaces.list();
   const byId = workspaces.find((w) => w.id === candidate);
-  if (byId) return byId.id;
+  if (byId) return byId;
   const bySlug = workspaces.find((w) => w.slug === candidate);
-  if (bySlug) return bySlug.id;
+  if (bySlug) return bySlug;
   const known = workspaces.map((w) => w.slug).join(", ");
   throw new Error(
     `Workspace "${candidate}" not found. Available: ${known || "(none)"}`
@@ -2235,7 +2604,7 @@ function createEpicsCommand() {
 }
 
 // src/commands/features.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/commands/stories.ts
 import { Command as Command6 } from "commander";
@@ -2656,6 +3025,240 @@ function createAreasCommand() {
   return areas;
 }
 
+// src/commands/featureComments.ts
+import { Command as Command10 } from "commander";
+
+// src/utils/mentions.ts
+function candidateLabels(member) {
+  const labels = [member.id];
+  if (member.name) {
+    labels.push(member.name);
+    const first = member.name.trim().split(/\s+/)[0];
+    if (first) labels.push(first);
+  }
+  if (member.email) {
+    labels.push(member.email);
+    const local = member.email.split("@")[0];
+    if (local) labels.push(local);
+  }
+  return labels;
+}
+function describe(member) {
+  return member.name ?? member.email ?? member.id;
+}
+function resolveMember(members, token) {
+  const needle = token.trim().toLowerCase().replace(/^@/, "");
+  const exact = members.filter(
+    (m) => m.id.toLowerCase() === needle || m.name?.toLowerCase() === needle || m.email?.toLowerCase() === needle
+  );
+  if (exact.length === 1) return exact[0];
+  if (exact.length > 1) {
+    throw new Error(
+      `"${token}" matches ${exact.length} members. Use a user id instead: ${exact.map((m) => `${describe(m)} (${m.id})`).join(", ")}`
+    );
+  }
+  const partial = members.filter(
+    (m) => candidateLabels(m).some((l) => l.toLowerCase() === needle)
+  );
+  if (partial.length === 1) return partial[0];
+  if (partial.length > 1) {
+    throw new Error(
+      `"${token}" is ambiguous \u2014 matches ${partial.map((m) => `${describe(m)} (${m.id})`).join(", ")}. Use a full name, email, or user id.`
+    );
+  }
+  const known = members.map(describe).join(", ");
+  throw new Error(
+    `No workspace member matches "${token}". Members: ${known || "(none)"}. Run \`exponential workspaces members\` to see the roster.`
+  );
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function applyMentions(client, workspaceId, body, mentions) {
+  if (!mentions || mentions.length === 0) return body;
+  const members = await client.workspaces.listMembers(workspaceId);
+  let result = body;
+  const prepend = [];
+  for (const token of mentions) {
+    const member = resolveMember(members, token);
+    const handle = token.trim().replace(/^@/, "");
+    const inline = new RegExp(`@${escapeRegExp(handle)}(?![\\w-])`, "gi");
+    const substituted = result.replace(inline, member.mentionSyntax);
+    if (substituted !== result) {
+      result = substituted;
+    } else if (!result.includes(member.mentionSyntax)) {
+      prepend.push(member.mentionSyntax);
+    }
+  }
+  return prepend.length > 0 ? `${prepend.join(" ")} ${result}` : result;
+}
+var MENTION_OPTION_DESCRIPTION = "Mention a workspace member by name, email, or id (repeatable). Writing @name in the message substitutes in place; otherwise the mention is prepended.";
+function collectMention(value, previous) {
+  return [...previous, value];
+}
+
+// src/commands/featureComments.ts
+function createFeatureCommentsCommand() {
+  const comment = new Command10("comment").description(
+    "Read and post comments on a feature. Mention teammates with --mention."
+  );
+  comment.command("list").description("List comments on a feature").requiredOption("--feature <id>", "Feature ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const comments = await client.featureComments.list(options.feature);
+      if (useJson) outputCommentsJson(comments);
+      else outputCommentsPretty(comments);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("add").description("Add a comment to a feature").requiredOption("--feature <id>", "Feature ID").requiredOption("-m, --message <text>", "Comment body (markdown supported)").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).option("--scope <id>", "Attach to a scope's activity feed instead of the feature").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const body = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const created = await client.featureComments.create({
+          featureId: options.feature,
+          scopeId: options.scope,
+          body
+        });
+        if (useJson) {
+          outputCommentJson(created);
+        } else {
+          console.log("\n\u2713 Comment added");
+          outputCommentPretty(created);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  comment.command("reply").description("Reply to a comment on a feature").requiredOption("--comment-id <id>", "Comment ID to reply to").requiredOption("-m, --message <text>", "Reply body (markdown supported)").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const body = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const created = await client.featureComments.reply({
+          parentId: options.commentId,
+          body
+        });
+        if (useJson) {
+          outputCommentJson(created);
+        } else {
+          console.log("\n\u2713 Reply 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 body").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const body = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const updated = await client.featureComments.update({
+          commentId: options.commentId,
+          body
+        });
+        if (useJson) {
+          outputCommentJson(updated);
+        } else {
+          console.log("\n\u2713 Comment updated");
+          outputCommentPretty(updated);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  comment.command("rm").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.featureComments.delete(options.commentId);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id: options.commentId }, null, 2));
+      } else {
+        console.log("\u2713 Comment deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("resolve").description("Resolve an anchored comment thread").requiredOption("--feature <id>", "Feature ID").requiredOption("--thread <id>", "Thread ID (anchored comments only)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.featureComments.resolve({
+        featureId: options.feature,
+        threadId: options.thread
+      });
+      if (useJson) {
+        console.log(JSON.stringify({ resolved: true, threadId: options.thread }, null, 2));
+      } else {
+        console.log("\u2713 Thread resolved");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("unresolve").description("Reopen a resolved comment thread").requiredOption("--feature <id>", "Feature ID").requiredOption("--thread <id>", "Thread ID (anchored comments only)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.featureComments.unresolve({
+        featureId: options.feature,
+        threadId: options.thread
+      });
+      if (useJson) {
+        console.log(JSON.stringify({ resolved: false, threadId: options.thread }, null, 2));
+      } else {
+        console.log("\u2713 Thread reopened");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return comment;
+}
+
 // src/commands/features.ts
 var FEATURE_STATUSES = [
   "IDEA",
@@ -2686,7 +3289,7 @@ function validateFeatureStatus(value) {
   return value;
 }
 function createFeaturesCommand() {
-  const features = new Command10("features").description(
+  const features = new Command11("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(
@@ -2934,11 +3537,12 @@ Aborted: ${reason}. Feature "${feature.name}" was NOT deleted.`);
   features.addCommand(createScopesCommand());
   features.addCommand(createRequirementsCommand());
   features.addCommand(createAreasCommand());
+  features.addCommand(createFeatureCommentsCommand());
   return features;
 }
 
 // src/commands/labels.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 import chalk5 from "chalk";
 var TRIAGE_LABELS = [
   { slug: "needs-triage", name: "needs-triage", color: "avatar-orange" },
@@ -2992,7 +3596,7 @@ async function resolveLabelIds(client, workspaceId, values) {
   return [...byId, ...resolvedFromSlugs];
 }
 function createLabelsCommand() {
-  const labels = new Command11("labels").description(
+  const labels = new Command12("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(
@@ -3095,7 +3699,7 @@ function createLabelsCommand() {
 }
 
 // src/commands/organizations.ts
-import { Command as Command12 } from "commander";
+import { Command as Command13 } from "commander";
 var VALID_SIZES = [
   "1-10",
   "11-50",
@@ -3105,7 +3709,7 @@ var VALID_SIZES = [
   "1000+"
 ];
 function createOrganizationsCommand() {
-  const organizations = new Command12("organizations").alias("orgs").description("Manage CRM organizations");
+  const organizations = new Command13("organizations").alias("orgs").description("Manage CRM organizations");
   organizations.command("list").description("List organizations").requiredOption("--workspace <id>", "Workspace ID").option("--search <query>", "Search by name or description").option("--industry <industry>", "Filter by industry").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);
@@ -3174,7 +3778,105 @@ function createOrganizationsCommand() {
 
 // src/commands/pages.ts
 import { readFileSync } from "fs";
-import { Command as Command13 } from "commander";
+import { Command as Command15 } from "commander";
+
+// src/commands/pageComments.ts
+import { Command as Command14 } from "commander";
+function createPageCommentsCommand() {
+  const comment = new Command14("comment").description(
+    "Read and post comments on a page. Mention teammates with --mention."
+  );
+  comment.command("list").description("List comments on a page").requiredOption("--page <id>", "Page ID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const comments = await client.pageComments.list(options.page);
+      if (useJson) outputCommentsJson(comments);
+      else outputCommentsPretty(comments);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("add").description("Add a comment to a page").requiredOption("--page <id>", "Page ID").requiredOption("-m, --message <text>", "Comment body (markdown supported)").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const body = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const created = await client.pageComments.create({
+          pageId: options.page,
+          body
+        });
+        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 body").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const body = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const updated = await client.pageComments.update({
+          commentId: options.commentId,
+          body
+        });
+        if (useJson) {
+          outputCommentJson(updated);
+        } else {
+          console.log("\n\u2713 Comment updated");
+          outputCommentPretty(updated);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  comment.command("rm").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.pageComments.delete(options.commentId);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id: options.commentId }, null, 2));
+      } else {
+        console.log("\u2713 Comment deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return comment;
+}
+
+// src/commands/pages.ts
 function readBody(body, bodyFile) {
   if (body !== void 0) return body;
   if (bodyFile === void 0) return void 0;
@@ -3182,7 +3884,7 @@ function readBody(body, bodyFile) {
   return readFileSync(bodyFile, "utf-8");
 }
 function createPagesCommand() {
-  const pages = new Command13("pages").description(
+  const pages = new Command15("pages").description(
     'Manage Knowledge pages (PRDs, research, technical specs). Link one to a feature with "features link-page".'
   );
   pages.command("list").description("List pages in a workspace").option("--workspace <slug|id>", "Workspace (defaults to the configured default)").option("--search <text>", "Filter by title/content").action(
@@ -3260,13 +3962,14 @@ function createPagesCommand() {
       }
     }
   );
+  pages.addCommand(createPageCommentsCommand());
   return pages;
 }
 
 // src/commands/products.ts
-import { Command as Command14 } from "commander";
+import { Command as Command16 } from "commander";
 function createProductsCommand() {
-  const products = new Command14("products").description(
+  const products = new Command16("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) => {
@@ -3329,9 +4032,9 @@ function createProductsCommand() {
 }
 
 // src/commands/projects.ts
-import { Command as Command15 } from "commander";
+import { Command as Command17 } from "commander";
 function createProjectsCommand() {
-  const projects = new Command15("projects").description("Manage projects");
+  const projects = new Command17("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);
@@ -3354,7 +4057,7 @@ function createProjectsCommand() {
 }
 
 // src/commands/search.ts
-import { Command as Command16 } from "commander";
+import { Command as Command18 } from "commander";
 import chalk6 from "chalk";
 var TYPE_LABELS = {
   workspace: "Workspaces",
@@ -3373,7 +4076,7 @@ var TYPE_LABELS = {
   product: "Products"
 };
 function createSearchCommand() {
-  const search = new Command16("search").description(
+  const search = new Command18("search").description(
     "Global search across projects, actions, goals, workspaces and more \u2014 same coverage as the app's Cmd+K palette"
   ).argument("<query>", "Text to search for").option("-w, --workspace <slug>", "Restrict results to one workspace (slug or ID)").option("-l, --limit <n>", "Max results per entity type (1-25, default 10)").action(async (query, options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -3432,7 +4135,7 @@ ${TYPE_LABELS[type] ?? type}`));
 }
 
 // src/commands/tickets.ts
-import { Command as Command17 } from "commander";
+import { Command as Command19 } from "commander";
 function collectRepeatable(value, previous) {
   return [...previous, value];
 }
@@ -3475,7 +4178,7 @@ function validateTicketType(value) {
   return value;
 }
 function createTicketsCommand() {
-  const tickets = new Command17("tickets").description(
+  const tickets = new Command19("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(
@@ -3789,25 +4492,78 @@ function createTicketsCommand() {
       handleError(error, useJson);
     }
   });
-  const comment = new Command17("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 comment = new Command19("comment").description("Manage comments on a ticket");
+  comment.command("list").description("List comments on a ticket").requiredOption("--id <id>", "Ticket CUID").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);
-      }
+      const ticket = await client.tickets.get(options.id);
+      const comments = ticket.comments ?? [];
+      if (useJson) outputCommentsJson(comments);
+      else outputCommentsPretty(comments);
     } catch (error) {
       handleError(error, useJson);
     }
   });
+  comment.command("add").description("Add a comment to a ticket").requiredOption("--id <id>", "Ticket CUID").requiredOption("-m, --message <text>", "Comment content (markdown supported)").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const content = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const created = await client.tickets.addComment({
+          ticketId: options.id,
+          content
+        });
+        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 ticket comments").requiredOption("--comment-id <id>", "Comment ID").requiredOption("-m, --message <text>", "New comment content").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const content = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const updated = await client.tickets.updateComment({
+          id: options.commentId,
+          content
+        });
+        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 ticket comments").requiredOption("--comment-id <id>", "Comment ID").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -3828,10 +4584,10 @@ function createTicketsCommand() {
 }
 
 // src/commands/workspaces.ts
-import { Command as Command18 } from "commander";
+import { Command as Command20 } from "commander";
 import chalk7 from "chalk";
 function createWorkspacesCommand() {
-  const workspaces = new Command18("workspaces").description("Manage workspaces");
+  const workspaces = new Command20("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);
@@ -3873,11 +4629,759 @@ function createWorkspacesCommand() {
       handleError(error);
     }
   });
+  workspaces.command("members").description(
+    "List workspace members. Each row carries the exact @[Name](id) markup to paste into a comment to mention that person."
+  ).option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").option("--search <text>", "Filter by name or email").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);
+        let members = await client.workspaces.listMembers(workspaceId);
+        if (options.search) {
+          const needle = options.search.toLowerCase();
+          members = members.filter(
+            (m) => m.name?.toLowerCase().includes(needle) || m.email?.toLowerCase().includes(needle)
+          );
+        }
+        if (useJson) {
+          console.log(
+            JSON.stringify({ members, total: members.length }, null, 2)
+          );
+          return;
+        }
+        if (members.length === 0) {
+          console.log(chalk7.gray("No members found."));
+          return;
+        }
+        console.log(chalk7.bold(`
+Members (${members.length})
+`));
+        for (const m of members) {
+          const label = m.name ?? m.email ?? m.id;
+          const via = m.source === "team" ? chalk7.gray(
+            ` via team${m.teams.length ? `: ${m.teams.map((t) => t.name).join(", ")}` : ""}` + (m.teamRole ? ` [team ${m.teamRole}]` : "")
+          ) : "";
+          console.log(`${chalk7.bold(label)} ${chalk7.gray(`(${m.role})`)}${via}`);
+          if (m.email) console.log(chalk7.gray(`  ${m.email}`));
+          console.log(chalk7.gray(`  mention: ${m.mentionSyntax}`));
+          console.log();
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
   return workspaces;
 }
 
+// src/commands/goals.ts
+import { Command as Command21 } from "commander";
+var GOAL_STATUSES = [
+  "planned",
+  "active",
+  "completed",
+  "archived",
+  "on-hold"
+];
+var GOAL_WRITABLE_STATUSES = [
+  "planned",
+  "active",
+  "completed",
+  "archived"
+];
+var KEY_RESULT_STATUSES = [
+  "not-started",
+  "on-track",
+  "at-risk",
+  "off-track",
+  "achieved"
+];
+var KEY_RESULT_UNITS = [
+  "percent",
+  "count",
+  "currency",
+  "hours",
+  "custom"
+];
+function currentPeriod() {
+  const now = /* @__PURE__ */ new Date();
+  return `Q${Math.floor(now.getMonth() / 3) + 1}-${now.getFullYear()}`;
+}
+async function targetWorkspaces(client, options) {
+  if (options.allWorkspaces) {
+    if (options.workspace) {
+      throw new Error("--workspace and --all-workspaces are mutually exclusive.");
+    }
+    return await client.workspaces.list();
+  }
+  return [await resolveWorkspace(client, options.workspace)];
+}
+async function fanOutByWorkspace(workspaces, read) {
+  const settled = await Promise.allSettled(workspaces.map(read));
+  const items = [];
+  const skipped = [];
+  settled.forEach((result, i) => {
+    if (result.status === "fulfilled") {
+      items.push(...result.value);
+      return;
+    }
+    const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+    skipped.push(`${workspaces[i].slug}: ${reason}`);
+  });
+  if (skipped.length === workspaces.length) {
+    const [first] = settled.filter((r) => r.status === "rejected");
+    throw first.reason;
+  }
+  for (const line of skipped) {
+    console.error(`Warning: skipped workspace ${line}`);
+  }
+  return items;
+}
+function parseGoalId(value) {
+  const id = Number(value);
+  if (!Number.isInteger(id)) {
+    throw new Error(
+      `Goal id must be a whole number, got "${value}". List them with \`exponential goals list\`.`
+    );
+  }
+  return id;
+}
+function parseNumber(value, label) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) {
+    throw new Error(`${label} must be a number, got "${value}".`);
+  }
+  return n;
+}
+function validateGoalStatus(value) {
+  if (!value) return void 0;
+  if (!GOAL_STATUSES.includes(value)) {
+    throw new Error(`Invalid status "${value}". Valid: ${GOAL_STATUSES.join(", ")}`);
+  }
+  return value;
+}
+function validateWritableGoalStatus(value) {
+  if (!value) return void 0;
+  if (!GOAL_WRITABLE_STATUSES.includes(value)) {
+    const extra = value === "on-hold" ? " Use `goals set-status` for on-hold." : "";
+    throw new Error(
+      `Invalid status "${value}". Valid: ${GOAL_WRITABLE_STATUSES.join(", ")}.${extra}`
+    );
+  }
+  return value;
+}
+function validateKeyResultStatus(value) {
+  if (!value) return void 0;
+  if (!KEY_RESULT_STATUSES.includes(value)) {
+    throw new Error(
+      `Invalid status "${value}". Valid: ${KEY_RESULT_STATUSES.join(", ")}`
+    );
+  }
+  return value;
+}
+function validateKeyResultUnit(value) {
+  if (!value) return void 0;
+  if (!KEY_RESULT_UNITS.includes(value)) {
+    throw new Error(`Invalid unit "${value}". Valid: ${KEY_RESULT_UNITS.join(", ")}`);
+  }
+  return value;
+}
+function createKeyResultsCommand() {
+  const kr = new Command21("kr").description(
+    "Key results on an objective. Ids are CUIDs; --goal takes the objective's integer id."
+  );
+  kr.command("list").description("List key results").option("--goal <id>", "Objective ID (a number)").option("-w, --workspace <slug|id>", "Workspace (workspace-wide: every member's KRs)").option("--period <period>", "Period, e.g. Q3-2026").option("--status <status>", `Filter by status: ${KEY_RESULT_STATUSES.join(", ")}`).option("--mine", "Narrow a workspace list to key results you own").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateKeyResultStatus(options.status);
+        const client = getClient();
+        const workspaceId = options.workspace ? await resolveWorkspaceId(client, options.workspace) : void 0;
+        const list = await client.goals.keyResults.list({
+          workspaceId,
+          goalId: options.goal ? parseGoalId(options.goal) : void 0,
+          period: options.period,
+          status,
+          onlyMine: options.mine
+        });
+        if (useJson) outputKeyResultsJson(list);
+        else outputKeyResultsPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  kr.command("get <id>").description("Get a key result by CUID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const keyResult = await getClient().goals.keyResults.get(id);
+      if (useJson) outputKeyResultJson(keyResult);
+      else outputKeyResultPretty(keyResult);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  kr.command("create").description("Create a key result on an objective").requiredOption("--goal <id>", "Objective ID (a number)").requiredOption("-t, --title <text>", "Key result title").requiredOption("--target <n>", "Target value").option("--start <n>", "Starting value (default 0)").option("--current <n>", "Current value (defaults to the start value)").option("--unit <unit>", `Unit: ${KEY_RESULT_UNITS.join(", ")}`).option("--period <period>", "Period, e.g. Q3-2026 (defaults to the objective's)").option("-d, --description <text>", "Description").option("--dri <userId>", "Directly responsible individual (user ID)").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const unit = validateKeyResultUnit(options.unit);
+        const client = getClient();
+        const goalId = parseGoalId(options.goal);
+        const startValue = options.start ? parseNumber(options.start, "--start") : void 0;
+        let period = options.period;
+        let workspaceId;
+        if (!period) {
+          const goal = await client.goals.get(goalId);
+          if (!goal.period) {
+            throw new Error(
+              `Objective #${goalId} has no period, so --period is required. See \`exponential goals periods\`.`
+            );
+          }
+          period = goal.period;
+          workspaceId = goal.workspaceId ?? void 0;
+        }
+        const keyResult = await client.goals.keyResults.create({
+          goalId,
+          workspaceId,
+          title: options.title,
+          targetValue: parseNumber(options.target, "--target"),
+          startValue,
+          currentValue: options.current ? parseNumber(options.current, "--current") : startValue,
+          unit,
+          period,
+          description: options.description,
+          driUserId: options.dri
+        });
+        if (useJson) outputKeyResultJson(keyResult);
+        else {
+          console.log("\n\u2713 Key result created");
+          outputKeyResultPretty(keyResult);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  kr.command("update").description("Update a key result (only the flags you pass are written)").requiredOption("--id <cuid>", "Key result CUID").option("-t, --title <text>", "New title").option("-d, --description <text>", "New description").option("--current <n>", "Current value (prefer `kr checkin` \u2014 it records history)").option("--target <n>", "Target value").option("--start <n>", "Starting value").option("--unit <unit>", `Unit: ${KEY_RESULT_UNITS.join(", ")}`).option("--status <status>", `Status: ${KEY_RESULT_STATUSES.join(", ")}`).option("--confidence <n>", "Confidence 0-100").option("--dri <userId>", "Directly responsible individual (user ID)").option("--goal <id>", "Move the key result to a different objective").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateKeyResultStatus(options.status);
+        const unit = validateKeyResultUnit(options.unit);
+        const keyResult = await getClient().goals.keyResults.update({
+          id: options.id,
+          title: options.title,
+          description: options.description,
+          currentValue: options.current ? parseNumber(options.current, "--current") : void 0,
+          targetValue: options.target ? parseNumber(options.target, "--target") : void 0,
+          startValue: options.start ? parseNumber(options.start, "--start") : void 0,
+          unit,
+          status,
+          confidence: options.confidence ? parseNumber(options.confidence, "--confidence") : void 0,
+          driUserId: options.dri,
+          goalId: options.goal ? parseGoalId(options.goal) : void 0
+        });
+        if (useJson) outputKeyResultJson(keyResult);
+        else {
+          console.log("\n\u2713 Key result updated");
+          outputKeyResultPretty(keyResult);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  kr.command("checkin").description(
+    "Record a progress check-in. Moves the value AND re-derives the status from where it lands between start and target."
+  ).requiredOption("--id <cuid>", "Key result CUID").requiredOption("--value <n>", "New current value").option("--note <text>", "Check-in note").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const checkIn = await getClient().goals.keyResults.checkIn({
+          id: options.id,
+          value: parseNumber(options.value, "--value"),
+          note: options.note
+        });
+        if (useJson) outputCheckInJson(checkIn);
+        else {
+          console.log("\n\u2713 Check-in recorded");
+          outputCheckInPretty(checkIn);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  kr.command("delete").description("Delete a key result").requiredOption("--id <cuid>", "Key result CUID").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      await getClient().goals.keyResults.delete(options.id);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id: options.id }, null, 2));
+      } else {
+        console.log("\u2713 Key result deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  kr.command("link").description("Link executing work (a project or a feature) to a key result").requiredOption("--id <cuid>", "Key result CUID").option("--project <cuid>", "Project CUID").option("--feature <cuid>", "Feature CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        if (!options.project === !options.feature) {
+          throw new Error("Pass exactly one of --project or --feature.");
+        }
+        const client = getClient();
+        const result = options.project ? await client.goals.keyResults.linkProject({
+          keyResultId: options.id,
+          projectId: options.project
+        }) : await client.goals.keyResults.linkFeature({
+          keyResultId: options.id,
+          featureId: options.feature
+        });
+        if (useJson) console.log(JSON.stringify(result, null, 2));
+        else console.log(`
+\u2713 ${options.project ? "Project" : "Feature"} linked`);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  kr.command("unlink").description("Unlink a project or feature from a key result").requiredOption("--id <cuid>", "Key result CUID").option("--project <cuid>", "Project CUID").option("--feature <cuid>", "Feature CUID").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        if (!options.project === !options.feature) {
+          throw new Error("Pass exactly one of --project or --feature.");
+        }
+        const client = getClient();
+        const result = options.project ? await client.goals.keyResults.unlinkProject({
+          keyResultId: options.id,
+          projectId: options.project
+        }) : await client.goals.keyResults.unlinkFeature({
+          keyResultId: options.id,
+          featureId: options.feature
+        });
+        if (useJson) console.log(JSON.stringify(result, null, 2));
+        else console.log(`
+\u2713 ${options.project ? "Project" : "Feature"} unlinked`);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  return kr;
+}
+function createGoalCommentsCommand() {
+  const comment = new Command21("comment").description(
+    "Read and post comments on a goal. Mention teammates with --mention."
+  );
+  comment.command("list").description("List comments on a goal").requiredOption("--goal <id>", "Goal ID (a number)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const comments = await client.goalComments.list(parseGoalId(options.goal));
+      if (useJson) outputCommentsJson(comments);
+      else outputCommentsPretty(comments);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  comment.command("add").description("Add a comment to a goal").requiredOption("--goal <id>", "Goal ID (a number)").requiredOption("-m, --message <text>", "Comment content (markdown supported)").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).option("--parent-update <id>", "Thread under a specific goal update").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const goalId = parseGoalId(options.goal);
+        const content = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const created = await client.goalComments.add({
+          goalId,
+          content,
+          parentUpdateId: options.parentUpdate
+        });
+        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").option("--mention <name>", MENTION_OPTION_DESCRIPTION, collectMention, []).option(
+    "--workspace <slug|id>",
+    "Workspace used to resolve --mention (defaults to your default workspace)"
+  ).action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const content = options.mention.length > 0 ? await applyMentions(
+          client,
+          await resolveWorkspaceId(client, options.workspace),
+          options.message,
+          options.mention
+        ) : options.message;
+        const updated = await client.goalComments.update({
+          commentId: options.commentId,
+          content
+        });
+        if (useJson) {
+          outputCommentJson(updated);
+        } else {
+          console.log("\n\u2713 Comment updated");
+          outputCommentPretty(updated);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  comment.command("rm").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.goalComments.delete(options.commentId);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id: options.commentId }, null, 2));
+      } else {
+        console.log("\u2713 Comment deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return comment;
+}
+function createGoalsCommand() {
+  const goals = new Command21("goals").description(
+    "Manage goals (objectives) and their key results. Objectives have integer ids; key results are CUIDs."
+  );
+  goals.command("list").description(
+    "List objectives, each with the projects linked to it \u2014 the join that ties an action (which carries a projectId) back to a goal."
+  ).option("-w, --workspace <slug|id>", "Workspace slug or ID (defaults to your default workspace)").option("--all-workspaces", "List across every workspace you belong to").option("--period <period>", "Filter by period, e.g. Q3-2026").option("--status <status>", `Filter by status: ${GOAL_STATUSES.join(", ")}`).option("--tree", "Render the parent/child cascade instead of a flat list").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateGoalStatus(options.status);
+        const client = getClient();
+        const workspaces = await targetWorkspaces(client, options);
+        if (options.tree) {
+          const trees = await fanOutByWorkspace(
+            workspaces,
+            (w) => client.goals.tree({ workspaceId: w.id, status })
+          );
+          const filtered = options.period ? trees.filter((g) => g.period === options.period) : trees;
+          if (useJson) outputGoalTreeJson(filtered);
+          else outputGoalTreePretty(filtered);
+          return;
+        }
+        const list = await fanOutByWorkspace(workspaces, async (workspace) => {
+          const goals2 = await client.goals.list({
+            workspaceId: workspace.id,
+            period: options.period,
+            status
+          });
+          return goals2.map((g) => ({ ...g, workspace: g.workspace ?? workspace }));
+        });
+        if (useJson) outputGoalsJson(list);
+        else outputGoalsPretty(list);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  goals.command("get <id>").description("Get an objective by its integer ID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const goal = await getClient().goals.get(parseGoalId(id));
+      if (useJson) outputGoalJson(goal);
+      else outputGoalPretty(goal);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  goals.command("create").description("Create an objective").requiredOption("-t, --title <text>", "Objective title").option("-w, --workspace <slug|id>", "Workspace slug or ID (defaults to your default workspace)").option("--period <period>", "Period, e.g. Q3-2026 or Annual-2026").option("--status <status>", `Status: ${GOAL_WRITABLE_STATUSES.join(", ")}`).option("-d, --description <text>", "Description (markdown supported)").option("--why <text>", "Why this goal matters").option("--dri <userId>", "Directly responsible individual (user ID)").option("--parent <id>", "Parent objective ID to nest under (max depth 5)").option("--project <cuid>", "Link a project on creation").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateWritableGoalStatus(options.status);
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const goal = await client.goals.create({
+          title: options.title,
+          workspaceId,
+          period: options.period,
+          status,
+          description: options.description,
+          whyThisGoal: options.why,
+          driUserId: options.dri,
+          parentGoalId: options.parent ? parseGoalId(options.parent) : void 0,
+          projectId: options.project
+        });
+        if (useJson) outputGoalJson(goal);
+        else {
+          console.log("\n\u2713 Goal created");
+          outputGoalPretty(goal);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  goals.command("update").description(
+    "Update an objective. Only the flags you pass are written \u2014 everything else is left exactly as it is. For a status change use `set-status`; to re-parent use `reparent`."
+  ).requiredOption("--id <n>", "Objective ID (a number)").option("-t, --title <text>", "New title").option("-d, --description <text>", 'New description ("none" clears it)').option("--why <text>", 'Why this goal matters ("none" clears it)').option("--period <period>", 'New period ("none" clears it)').option("--dri <userId>", "Directly responsible individual (user ID)").option("--status <status>", `Status: ${GOAL_WRITABLE_STATUSES.join(", ")}`).option("--project <cuid>", 'Replace the project links with this project ("none" clears them)').action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateWritableGoalStatus(options.status);
+        const clearable = (value) => value === void 0 ? void 0 : value === "none" ? null : value;
+        const goal = await getClient().goals.update({
+          id: parseGoalId(options.id),
+          title: options.title,
+          description: clearable(options.description),
+          whyThisGoal: clearable(options.why),
+          period: clearable(options.period),
+          driUserId: options.dri,
+          status,
+          projectId: clearable(options.project)
+        });
+        if (useJson) outputGoalJson(goal);
+        else {
+          console.log("\n\u2713 Goal updated");
+          outputGoalPretty(goal);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  goals.command("set-status").description(
+    "Set an objective's status and nothing else. Routes through the status-only procedure, so no other field can be touched."
+  ).requiredOption("--id <n>", "Objective ID (a number)").requiredOption("--status <status>", `Status: ${GOAL_STATUSES.join(", ")}`).action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const status = validateGoalStatus(options.status);
+      const goal = await getClient().goals.setStatus({
+        id: parseGoalId(options.id),
+        status
+      });
+      if (useJson) outputGoalJson(goal);
+      else {
+        console.log(`
+\u2713 Goal status set to ${status}`);
+        outputGoalPretty(goal);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  goals.command("close").description("Close out an objective \u2014 one command per goal when a quarter ends").requiredOption("--id <n>", "Objective ID (a number)").option("--status <status>", "completed (default) or archived", "completed").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const status = validateGoalStatus(options.status);
+      const goal = await getClient().goals.setStatus({
+        id: parseGoalId(options.id),
+        status
+      });
+      if (useJson) outputGoalJson(goal);
+      else {
+        console.log(`
+\u2713 Goal closed as ${status}`);
+        outputGoalPretty(goal);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  goals.command("reparent").description(
+    "Move an objective under another (or detach it with --parent none). Writes the parent alone."
+  ).requiredOption("--id <n>", "Objective ID (a number)").requiredOption("--parent <id|none>", 'New parent objective ID, or "none" to detach').action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const goal = await getClient().goals.setParent({
+        id: parseGoalId(options.id),
+        parentGoalId: options.parent === "none" ? null : parseGoalId(options.parent)
+      });
+      if (useJson) outputGoalJson(goal);
+      else {
+        console.log(
+          options.parent === "none" ? "\n\u2713 Goal detached" : "\n\u2713 Goal re-parented"
+        );
+        outputGoalPretty(goal);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  goals.command("delete").description("Delete an objective").requiredOption("--id <n>", "Objective ID (a number)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const id = parseGoalId(options.id);
+      await getClient().goals.delete(id);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id }, null, 2));
+      } else {
+        console.log("\u2713 Goal deleted");
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  goals.command("periods").description("List the conventional OKR period strings").action(async (_options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const periods = await getClient().goals.periods();
+      if (useJson) outputGoalPeriodsJson(periods);
+      else outputGoalPeriodsPretty(periods);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  goals.command("stats").description("Objective and key-result counts, average progress and confidence").option("-w, --workspace <slug|id>", "Workspace slug or ID (defaults to your default workspace)").option("--period <period>", "Period, e.g. Q3-2026").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 stats = await client.goals.stats({
+          workspaceId,
+          period: options.period
+        });
+        if (useJson) outputGoalStatsJson(stats);
+        else outputGoalStatsPretty(stats);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  goals.addCommand(createKeyResultsCommand());
+  goals.addCommand(createGoalCommentsCommand());
+  return goals;
+}
+function createOkrsCommand() {
+  const okrs = new Command21("okrs").description(
+    "OKRs \u2014 objectives with their key results nested. Manage the parts with `goals` and `goals kr`."
+  );
+  okrs.command("list").description(
+    "List objectives with their key results. Defaults to the current quarter \u2014 pass --period all for every period."
+  ).option("-w, --workspace <slug|id>", "Workspace slug or ID (defaults to your default workspace)").option("--all-workspaces", "List across every workspace you belong to").option(
+    "--period <period>",
+    `Period, e.g. Q3-2026, or "all" for every period (default: ${currentPeriod()})`
+  ).option("--paired-period", "Also include the period's parent annual period").option(
+    "--status <status>",
+    `Keep only key results with this status: ${KEY_RESULT_STATUSES.join(", ")}`
+  ).option("--mine", "Only objectives and key results you are the DRI for").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = validateKeyResultStatus(options.status);
+        const client = getClient();
+        const workspaces = await targetWorkspaces(client, options);
+        const period = options.period === "all" ? void 0 : options.period ?? currentPeriod();
+        let objectives = await fanOutByWorkspace(workspaces, async (workspace) => {
+          const found = await client.goals.keyResults.byObjective({
+            workspaceId: workspace.id,
+            period,
+            includePairedPeriod: options.pairedPeriod,
+            onlyMine: options.mine
+          });
+          return found.map((o) => ({ ...o, workspace }));
+        });
+        if (status) {
+          objectives = objectives.map((o) => ({
+            ...o,
+            keyResults: o.keyResults.filter(
+              (kr) => (kr.statusOverride ?? kr.status) === status
+            )
+          })).filter((o) => o.keyResults.length > 0);
+        }
+        if (useJson) outputObjectivesJson(objectives);
+        else outputObjectivesPretty(objectives);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  okrs.command("stats").description("Objective and key-result counts, average progress and confidence").option("-w, --workspace <slug|id>", "Workspace slug or ID (defaults to your default workspace)").option("--period <period>", "Period, e.g. Q3-2026").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 stats = await client.goals.stats({
+          workspaceId,
+          period: options.period
+        });
+        if (useJson) outputGoalStatsJson(stats);
+        else outputGoalStatsPretty(stats);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  okrs.command("periods").description("List the conventional OKR period strings").action(async (_options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const periods = await getClient().goals.periods();
+      if (useJson) outputGoalPeriodsJson(periods);
+      else outputGoalPeriodsPretty(periods);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  okrs.addCommand(createKeyResultsCommand());
+  return okrs;
+}
+
 // src/index.ts
-var program = new Command19();
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var PKG_VERSION = JSON.parse(
+  readFileSync2(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8")
+).version;
+var program = new Command22();
 program.name("exponential").description(
   [
     "CLI to interact with Exponential productivity app.",
@@ -3886,7 +5390,7 @@ program.name("exponential").description(
     "  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");
+).version(PKG_VERSION).option("--json", "Output as JSON (default when piped)").option("--pretty", "Force pretty-printed output");
 program.addCommand(createAuthCommand());
 program.addCommand(createActionsCommand());
 program.addCommand(createContactsCommand());
@@ -3901,5 +5405,7 @@ program.addCommand(createProjectsCommand());
 program.addCommand(createSearchCommand());
 program.addCommand(createTicketsCommand());
 program.addCommand(createWorkspacesCommand());
+program.addCommand(createGoalsCommand());
+program.addCommand(createOkrsCommand());
 program.parse();
 //# sourceMappingURL=index.js.map