exponential-cli 1.10.0 → 1.11.0

package/dist/index.js

@@ -1411,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 = [
@@ -2114,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) {
@@ -2123,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)"}`
@@ -4338,19 +4678,313 @@ Members (${members.length})
 
 // 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}". Find one with \`exponential search "<goal title>"\`.`
+      `Goal id must be a whole number, got "${value}". List them with \`exponential goals list\`.`
     );
   }
   return id;
 }
-function createGoalsCommand() {
-  const goals = new Command21("goals").description(
-    'Work with goals. Find goal ids with `exponential search "<title>"`.'
+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."
   );
@@ -4443,9 +5077,302 @@ function createGoalsCommand() {
       handleError(error, useJson);
     }
   });
-  goals.addCommand(comment);
+  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
 import { readFileSync as readFileSync2 } from "fs";
@@ -4479,5 +5406,6 @@ program.addCommand(createSearchCommand());
 program.addCommand(createTicketsCommand());
 program.addCommand(createWorkspacesCommand());
 program.addCommand(createGoalsCommand());
+program.addCommand(createOkrsCommand());
 program.parse();
 //# sourceMappingURL=index.js.map