@harborppm/cli 0.98.0 → 0.100.0

package/lib/cli.mjs

@@ -21,8 +21,8 @@ import {
   importText,
   forecastList,
   forecastOne,
-  STATUS,
   statusWord,
+  statusText,
   exportData,
   harbors,
   whoami,
@@ -42,6 +42,10 @@ import {
   followedText,
   soundingsText,
   goalsText,
+  goalText,
+  milestonesText,
+  milestoneLine,
+  reportsText,
   templatesText,
   approvalsText,
   thanksText,
@@ -172,7 +176,8 @@ export const HELP = `harbor: Harbor from the terminal
                      [--also "NAME, NAME"] [--due DATE|pilot] [--starts DATE]
                      [--priority low|medium|high|urgent]
                      [--status S] [--comment TEXT] [--over-limit] [--dry-run]
-                     [--literal] [--template NAME] [--parent TASK]
+                     [--unless-exists] [--literal] [--template NAME]
+                     [--parent TASK]
                      [--milestone NAME]
                                               reads plain words in TITLE as the
                                               website does: @name, by friday,
@@ -259,6 +264,9 @@ export const HELP = `harbor: Harbor from the terminal
   harbor messages PROJECT ["TEXT"] [--limit N]
                                               a project's messages, or write
                                               one (@Name tells them)
+  harbor messages PROJECT --edit "TEXT" [--message ID]
+                                              fix your latest message (or that
+                                              one) in its project
   harbor charter PROJECT [--why T] [--in T] [--out T] [--done-when T]
                          [--calls NAME]
                                               a project's five-line charter
@@ -280,6 +288,23 @@ export const HELP = `harbor: Harbor from the terminal
                                               the ones waiting on your answer
   harbor goals [PORTFOLIO]                    each portfolio's goals, how far
                                               along and whether on track
+  harbor goal "GOAL" [--title T] [--owner NAME] [--due DATE|none] [--why T]
+              [--link WORK] [--unlink WORK] [--kr "KR" [--at N|--target N]]
+                                              change a goal, count work toward
+                                              it, or move a key result
+  harbor goal "TITLE" --new [--portfolio P] [--owner NAME] [--due DATE]
+                                              set a new goal (harbor help goal)
+  harbor milestones [PROGRAM] [--project P] [--done]
+                                              milestones soonest first: tasks
+                                              done, sign-off, what they wait on
+  harbor milestone "NAME" [--program P] [--due DATE] [--rename T]
+                   [--reached|--open] [--signs-off NAME|none]
+                   [--approve|--changes NOTE]
+                                              change one, or sign it off
+  harbor milestone "NAME" --new --program P --due DATE
+                                              add one to a program
+  harbor reports [DASHBOARD]                  the Reports page's dashboards,
+                                              each chart as its numbers
   harbor templates [PROJECT]                  the task templates new tasks
                                               start from (harbor add --template)
   harbor template TASK [--name NAME]          save a task as a template in its
@@ -326,8 +351,10 @@ export const HELP = `harbor: Harbor from the terminal
 
   Every command takes --json, and --harbor NAME when you're in more than one
   harbor (or set one with harbor use). harbor help COMMAND shows just that one.
-  Statuses: backlog, todo, doing, review, done (the board's words work too:
-  "to do", "in play"; --json says doing for In play).
+  Statuses: backlog, todo, doing, review, done. The board's words work
+  too ("to do", "in play", "in progress", "in review"), and harbor tasks
+  takes --status all. Lists say your board's own name for a column it
+  renamed; --json keeps Harbor's word in status and the board's in column.
   DATE: YYYY-MM-DD, today, tomorrow, or +N for N days from today.
   Changes show in Harbor's History as yours, "via Harbor CLI". These commands
   never delete; the full-screen app can, as the website can, and asks first,
@@ -615,6 +642,16 @@ function dueWords(v) {
   return /^\d{4}-\d{2}-\d{2}$/.test(dueDate(v));
 }
 
+/** --status S,S as Harbor's words; "all" is every status, done ones included. */
+function statusList(typed) {
+  const list = typed
+    .split(",")
+    .map((x) => x.trim())
+    .filter(Boolean);
+  if (list.some((x) => x.toLowerCase() === "all")) return ["backlog", "todo", "doing", "review", "done"];
+  return list.map(statusWord);
+}
+
 /** --due pilot: the date the owner's queue suggests, set by Harbor. */
 const PILOT = new Set(["pilot", "suggested"]);
 const duePilot = (v) => (v !== undefined && PILOT.has(v.toLowerCase()) ? true : undefined);
@@ -786,6 +823,20 @@ const DETAIL = {
     "  harbor add --project P < titles.txt    writes: one task a line of stdin",
     "  harbor add --project P --dry-run       reads: says what it would add, and",
     "                                         adds nothing",
+    "  harbor add \"TITLE\" --unless-exists    writes: only if no open task in the",
+    "                                         project has that title (safe to retry)",
+    "",
+    "  --dry-run asks Harbor to add them on a copy that's thrown away, so it",
+    "  shows each one as it would really be: its likely key, column, owner,",
+    "  priority, dates, parent and milestone, the words read from its title,",
+    "  an open task that already has the title, and anything Harbor would",
+    "  refuse (a full column, an unknown person) with why. It exits 1 when",
+    "  something would be refused. --json lists the same under tasks.",
+    "",
+    "  --unless-exists skips a title the project already has open (case and",
+    "  spacing aside), saying which task it found; a done one doesn't count,",
+    "  so a weekly chore is still added. --json lists added and skipped tasks,",
+    "  each with its key, the same shape for one title or a hundred.",
     "",
     "  --project can be left out when the harbor has one open project (First",
     "  voyage aside); the task goes there.",
@@ -794,11 +845,17 @@ const DETAIL = {
     "  venue @Quinn by friday !high #Website\" adds \"Book the venue\" for",
     "  Quinn, due Friday, high priority, in Website. Harbor says what it read.",
     "  A flag wins over the words (they stay in the title), and --literal keeps",
-    "  every title exactly as typed.",
+    "  every title exactly as typed. What's read: a person after @ or \"assign",
+    "  to\"; a day after by, due, on, before or until, or as the very last",
+    "  words (\"Call the mill friday\"), never after to, for or from (\"Move",
+    "  the call to Friday\" keeps it); !high or \"high priority\"; #Project.",
+    "  With --dry-run --literal it says what the words would have read as.",
     "",
     "  --assignee me|none|NAME, --also \"NAME, NAME\" (others on it with the",
     "  owner), --due DATE|pilot, --priority low|medium|high|urgent,",
-    "  --status S, --comment TEXT and --over-limit apply to every task added, so",
+    "  --status S (backlog, todo, doing, review or done; \"in play\", \"in",
+    "  progress\" and the board's other words work too), --comment TEXT and",
+    "  --over-limit apply to every task added, so",
     "  ten lines with --comment add the same comment to all ten. More than 100",
     "  lines is harbor import's job.",
     "",
@@ -1135,6 +1192,62 @@ const DETAIL = {
     "                                         left out), off track first, with how far",
     "                                         along each key result is",
   ],
+  goal: [
+    '  harbor goal "GOAL"                     reads: one goal and its key results',
+    '  harbor goal "TITLE" --new [--portfolio P] [--owner NAME] [--due DATE] [--why T]',
+    "                                         writes: sets a new goal on a portfolio",
+    '  harbor goal "GOAL" --title T --owner NAME --due DATE|none --starts DATE|none',
+    "                   --why T              writes: changes it",
+    '  harbor goal "GOAL" --link WORK         writes: counts a program, project or',
+    "                                         task (RR-42) toward it; --unlink stops",
+    '  harbor goal "GOAL" --kr "KR" --at N    writes: moves a number key result',
+    '  harbor goal "GOAL" --kr "KR" --target N [--start N] [--unit U]',
+    "                                         writes: adds that number key result, or",
+    "                                         changes its numbers",
+    '  harbor goal "GOAL" --kr "KR" --counts "WORK, WORK"',
+    "                                         writes: adds a key result counting work",
+    "",
+    "  GOAL is its title, or enough of it to tell it apart. --link and",
+    "  --unlink take names separated by commas.",
+  ],
+  milestones: [
+    "  harbor milestones [PROGRAM]            reads: a program's open milestones",
+    "                                         (every program's when left out),",
+    "                                         soonest first",
+    "  harbor milestones --project P          reads: the milestones of P's program",
+    "",
+    "  Each says its due day and whether it's late, how many of the tasks tied",
+    "  to it are done, who signs it off and where that stands, and the",
+    "  projects it waits on. --done adds the reached ones.",
+  ],
+  milestone: [
+    '  harbor milestone "NAME"                reads: one milestone',
+    '  harbor milestone "NAME" --new --program P --due DATE',
+    "                                         writes: adds it to the program",
+    '  harbor milestone "NAME" --due DATE --rename T',
+    "                                         writes: moves or renames it",
+    '  harbor milestone "NAME" --reached|--open',
+    "                                         writes: ticks it reached, or opens it",
+    '  harbor milestone "NAME" --signs-off NAME|none',
+    "                                         writes: who signs it off (a stage gate)",
+    '  harbor milestone "NAME" --approve | --changes "WHAT"',
+    "                                         writes: your sign-off, if it's yours",
+    "",
+    "  A stage gate is reached only by its sign-off, so --reached is refused",
+    "  on one. A milestone with tasks tied to it (harbor add --milestone) is",
+    "  reached when they're done and opens again when one reopens. Without",
+    "  --new a name it doesn't know is refused with the program's milestones,",
+    "  so a typo never adds a second one. --program narrows the name when two",
+    "  programs use it.",
+  ],
+  reports: [
+    "  harbor reports                         reads: every dashboard on the Reports",
+    "                                         page, each chart as its numbers",
+    "  harbor reports DASHBOARD               reads: that one",
+    "",
+    "  Each chart says what it counts, how it's split and the part of the",
+    "  harbor it reads. Dashboards are made and changed on the website.",
+  ],
   soundings: [
     "  harbor soundings [PROJECT]             reads: open tasks with a sounding",
     "                                         (all projects when left out), and the",
@@ -1338,6 +1451,10 @@ const DETAIL = {
     "  One conversation for the whole project, for what isn't about one task;",
     "  harbor comment TASK is for that. @Name sends it to that person's Inbox.",
     "  Reading shows the newest 50, oldest first; --limit N shows up to 500.",
+    '  harbor messages PROJECT --edit "TEXT"  writes: changes your latest message',
+    "                                         there (--message ID: that one; --json",
+    "                                         on a read gives the ids). It shows as",
+    "                                         edited; only the writer can change one.",
   ],
   voyage: [
     "  harbor voyage PROJECT                  reads a Done project's voyage log",
@@ -1541,8 +1658,8 @@ const OTHER_NAMES = {
   longpole: "harbor why PROJECT shows what's holding it up.",
   "long-pole": "harbor why PROJECT shows what's holding it up.",
   pilot: "harbor show TASK says the date its owner's queue suggests; --due pilot on add or edit takes it.",
-  milestone: "Milestones belong to a program: in the app (harbor), open the program and press m; or on the website.",
-  milestones: "The app's program screen lists them: harbor, then 4, and Enter on a program.",
+  dashboards: "harbor reports lists the Reports page's dashboards, each chart as its numbers.",
+  report: "harbor report PROGRAM is a program's status report; harbor reports lists the dashboards.",
   decide: 'harbor decision "TITLE" --project P logs a decision.',
   dock: "harbor try PROJECT is the dry dock.",
   "dry-dock": "harbor try PROJECT is the dry dock.",
@@ -2309,16 +2426,21 @@ export async function run(argv, io = {}) {
         query: positionals.join(" ") || undefined,
         project: values.project,
         assignee: values.assignee,
-        status: values.status
-          ? values.status
-              .split(",")
-              .map((x) => x.trim())
-              .filter(Boolean)
-              .map(statusWord)
-          : undefined,
+        status: values.status ? statusList(values.status) : undefined,
         overdue: values.late || undefined,
       };
-      if (!values.all) return call("search_tasks", args, (r) => taskList(r, opts));
+      // Capped at 20 without --all: --json says so too (more, and how to get them),
+      // so a script counting tasks can't take the first page for all of them.
+      if (!values.all)
+        return call(
+          "search_tasks",
+          args,
+          (r) => taskList(r, opts),
+          (r) =>
+            r.total > (r.tasks?.length ?? 0)
+              ? { ...r, more: r.total - r.tasks.length, note: "Capped at 20; --all lists every one." }
+              : r,
+        );
       // --all pages through every match, PAGE at a time (search_tasks' most).
       const PAGE = 50;
       const tasks = [];
@@ -2395,7 +2517,7 @@ export async function run(argv, io = {}) {
             "",
             "Waits on:",
             ...t.waitingOn.map(
-              (w) => `  ${w.key ?? w.id}  ${w.title} (${STATUS[w.status] ?? w.status})`,
+              (w) => `  ${w.key ?? w.id}  ${w.title} (${statusText(w)})`,
             ),
           );
         if (t.waitedOnBy.length)
@@ -2403,7 +2525,7 @@ export async function run(argv, io = {}) {
             "",
             "Holds up:",
             ...t.waitedOnBy.map(
-              (w) => `  ${w.key ?? w.id}  ${w.title} (${STATUS[w.status] ?? w.status})`,
+              (w) => `  ${w.key ?? w.id}  ${w.title} (${statusText(w)})`,
             ),
           );
         if (t.files?.length) lines.push("", "Files:", ...t.files.map((f) => `  ${fileText(f)}`));
@@ -2624,7 +2746,7 @@ export async function run(argv, io = {}) {
     case "add": {
       const { positionals, values, harbor } = parse(
         spec(
-          ["over-limit", "dry-run", "literal"],
+          ["over-limit", "dry-run", "literal", "unless-exists"],
           ["project", "assignee", "also", "due", "starts", "priority", "status", "comment", "template", "parent", "milestone"],
         ),
       );
@@ -2662,82 +2784,134 @@ export async function run(argv, io = {}) {
       if (!values.project && !reads.every((r) => r.project))
         values.project = await onlyProject(client, harbor, "--project NAME or #NAME in the title");
       const projectOf = (r) => values.project ?? r.project?.value;
+      // What create_task gets for one line, the same for a dry run and the real thing.
+      const argsFor = (words) => ({
+        project: projectOf(words),
+        title: words.title || undefined,
+        template: values.template,
+        // Yours unless you say otherwise, as with n in the app (a template keeps its own owner).
+        assignee: values.assignee ?? words.owner?.value ?? (values.template ? undefined : "me"),
+        also: values.also === undefined ? undefined : alsoList(values.also),
+        due: duePilot(values.due) ? undefined : (dueDate(values.due) ?? words.due?.value),
+        suggestedDue: duePilot(values.due),
+        starts: dueDate(values.starts),
+        priority: values.priority ?? words.priority?.value,
+        status: values.status === undefined ? undefined : statusWord(values.status),
+        parent: values.parent,
+        milestone: values.milestone,
+        overLimit: values["over-limit"] || undefined,
+        unlessExists: values["unless-exists"] || undefined,
+      });
       if (values["dry-run"]) {
-        const n = titles.length === 1 ? "1 task" : `${titles.length} tasks`;
-        // --due pilot: the date each line would take, each counting the ones before it.
-        const pilot = duePilot(values.due)
-          ? (
-              await client.call("suggest_due", {
-                harbor,
-                project: values.project,
-                assignee: values.assignee ?? "me",
-                count: titles.length,
-              })
-            ).dates
-          : null;
-        const where = [...new Set(reads.map(projectOf))];
-        if (asJson)
+        // Harbor runs each one on a copy and says what it would be; nothing is saved.
+        const preview = await client
+          .call("preview_tasks", { harbor, tasks: reads.map(argsFor) })
+          .catch((err) => {
+            if (err instanceof HarborError) throw new HarborError(hint(err.message, values.project));
+            throw err;
+          });
+        // --literal: what the words would have read as, so it's plain what it kept.
+        const unread =
+          values.literal && !fromTemplate ? await readTitles(client, harbor, titles, values) : null;
+        const lines = preview.tasks.map((p, i) => {
+          const t = p.created;
+          const words = reads[i];
+          return {
+            title: t?.title ?? p.title ?? words.title,
+            ...(t
+              ? {
+                  key: t.key ?? null,
+                  project: t.project,
+                  status: t.status,
+                  ...(t.column ? { column: t.column } : {}),
+                  assignee: t.assignee,
+                  ...(t.alsoOn ? { alsoOn: t.alsoOn } : {}),
+                  priority: t.priority,
+                  due: t.due,
+                  ...(t.starts ? { starts: t.starts } : {}),
+                  ...(t.subtaskOf ? { subtaskOf: t.subtaskOf } : {}),
+                  ...(t.milestone ? { milestone: t.milestone } : {}),
+                }
+              : {}),
+            ...(values.template ? { template: values.template } : {}),
+            ...(values.comment ? { comment: values.comment } : {}),
+            ...(words.owner || words.due || words.priority || words.project
+              ? {
+                  read: {
+                    ...(words.owner ? { assignee: words.owner.value, from: words.owner.text } : {}),
+                    ...(words.due ? { due: words.due.value } : {}),
+                    ...(words.priority ? { priority: words.priority.value } : {}),
+                    ...(words.project ? { project: words.project.value } : {}),
+                  },
+                }
+              : {}),
+            ...(unread && wordsLine(unread[i]) ? { keptWords: wordsLine(unread[i]) } : {}),
+            ...(p.sameAs ? { sameAs: p.sameAs } : {}),
+            ...(p.sameAs && values["unless-exists"] ? { skipped: true } : {}),
+            ...(p.refused ? { refused: p.refused } : {}),
+          };
+        });
+        const refused = lines.filter((l) => l.refused).length;
+        const skipped = lines.filter((l) => l.skipped).length;
+        const would = lines.length - refused - skipped;
+        if (asJson) {
+          const where = [...new Set(lines.map((l) => l.project).filter(Boolean))];
           out(
             jsonText({
               dryRun: true,
-              project: where.length === 1 ? where[0] : values.project,
-              titles: reads.map((r) => r.title),
-              ...(reads.some((r) => r.owner || r.due || r.priority || r.project)
-                ? {
-                    read: reads.map((r) => ({
-                      project: projectOf(r),
-                      ...(r.owner ? { assignee: r.owner.value } : {}),
-                      ...(r.due ? { due: r.due.value } : {}),
-                      ...(r.priority ? { priority: r.priority.value } : {}),
-                    })),
-                  }
-                : {}),
-              ...(pilot
-                ? { due: pilot.map((d) => d.earliest) }
-                : values.due
-                  ? { due: titles.map(() => dueDate(values.due)) }
-                  : {}),
+              literal: Boolean(values.literal),
+              project: where.length === 1 ? where[0] : (values.project ?? null),
+              titles: lines.map((l) => l.title),
+              tasks: lines,
             }),
           );
-        else
+        } else {
+          const n = (k) => (k === 1 ? "1 task" : `${k} tasks`);
+          const body = lines.flatMap((l, i) => {
+            if (l.refused) return [`  ${l.title}`, `    Would be refused: ${l.refused}`];
+            const bits = [
+              l.key ? `as ${l.key}` : null,
+              statusText(l),
+              l.assignee ?? "nobody's",
+              l.alsoOn ? `with ${l.alsoOn.join(", ")}` : null,
+              l.priority !== "medium" ? `${l.priority} priority` : null,
+              l.due ? `due ${dayWithWeekday(l.due)}` : "no due date",
+              l.starts ? `starts ${l.starts}` : null,
+              l.subtaskOf ? `inside ${l.subtaskOf}` : null,
+              l.milestone ? `toward ${l.milestone}` : null,
+              l.project,
+            ].filter(Boolean);
+            const words = reads[i];
+            return [
+              `  ${l.title}${l.skipped ? "  (already there, skipped)" : ""}`,
+              `    ${bits.join(" · ")}`,
+              ...(wordsLine(words) ? [`    ${wordsLine(words)} --literal keeps them in the title.`] : []),
+              ...(l.keptWords
+                ? [`    --literal kept the words as typed. ${l.keptWords.replace("Read from your words", "Without it, they'd read as")}`]
+                : []),
+              ...(l.comment ? [`    with your comment: ${l.comment}`] : []),
+              ...(l.sameAs && !l.skipped
+                ? [`    ${l.sameAs} is already open with this title; --unless-exists skips it.`]
+                : []),
+            ];
+          });
+          const pilot = duePilot(values.due) && preview.tasks.find((p) => p.pilot)?.pilot;
           out(
             plain(
               [
-                `Would add ${n} to ${where.join(" and ")}:`,
-                ...reads.flatMap((r, i) => [
-                  `  ${r.title}${pilot ? `  (due ${pilot[i].earliest})` : values.due ? `  (due ${dueWords(values.due) ? dayWithWeekday(dueDate(values.due)) : dueDate(values.due)})` : ""}`,
-                  ...(wordsLine(r) ? [`    ${wordsLine(r)}`] : []),
-                ]),
-                ...(pilot
-                  ? [
-                      `--due pilot: ${pilot[0].says}; ${pilot[0].why.map((w) => w.charAt(0).toLowerCase() + w.slice(1)).join("; ")}.`,
-                    ]
-                  : []),
+                `Would add ${n(would)}${skipped ? `, skip ${skipped}` : ""}${refused ? `; ${refused} would be refused` : ""}. Nothing changed.`,
+                ...body,
+                ...(pilot ? [`--due pilot: ${pilot.says}`] : []),
               ].join("\n"),
             ),
           );
-        return 0;
+        }
+        return refused ? 1 : 0;
       }
       const added = [];
       for (const words of reads) {
         const r = await client
-          .call("create_task", {
-            harbor,
-            project: projectOf(words),
-            title: words.title || undefined,
-            template: values.template,
-            // Yours unless you say otherwise, as with n in the app (a template keeps its own owner).
-            assignee: values.assignee ?? words.owner?.value ?? (values.template ? undefined : "me"),
-            also: values.also === undefined ? undefined : alsoList(values.also),
-            due: duePilot(values.due) ? undefined : (dueDate(values.due) ?? words.due?.value),
-            suggestedDue: duePilot(values.due),
-            starts: dueDate(values.starts),
-            priority: values.priority ?? words.priority?.value,
-            status: values.status === undefined ? undefined : statusWord(values.status),
-            parent: values.parent,
-            milestone: values.milestone,
-            overLimit: values["over-limit"] || undefined,
-          })
+          .call("create_task", { harbor, ...argsFor(words) })
           .catch((err) => {
             if (err instanceof HarborError) {
               const done = added.length ? ` (added ${added.length} before it)` : "";
@@ -2745,6 +2919,11 @@ export async function run(argv, io = {}) {
             }
             throw err;
           });
+        // --unless-exists found it open already: nothing added, no comment.
+        if (r.existing) {
+          added.push(r);
+          continue;
+        }
         if (values.comment)
           r.comment = (
             await client.call("add_comment", {
@@ -2758,15 +2937,28 @@ export async function run(argv, io = {}) {
         added.push(r);
       }
       await stalePromptCache(env);
-      // `added` is always the list, so a script reads one key however many
-      // titles it sent; one title also keeps its `created` at the top.
-      if (asJson) out(jsonText(added.length === 1 ? { ...added[0], added } : { added }));
+      const made = added.filter((r) => r.created);
+      const kept = added.filter((r) => r.existing);
+      // One shape however many titles: `added` lists what was added and
+      // `skipped` what --unless-exists found open already, each entry with
+      // its key at the top; one title added also keeps its `created`.
+      const entry = (r, t) => ({ key: t.key ?? null, id: t.id, title: t.title, ...r });
+      if (asJson)
+        out(
+          jsonText({
+            ...(made.length === 1 && added.length === 1 ? made[0] : {}),
+            added: made.map((r) => entry(r, r.created)),
+            skipped: kept.map((r) => entry(r, r.existing)),
+          }),
+        );
       else
         out(
           plain(
             added
               .map((r) =>
-                [
+                r.existing
+                  ? `Already there, not added again: ${taskLine(r.existing, opts)}`
+                  : [
                   `Added: ${taskLine(r.created, opts)}${r.comment ? ", with your comment" : ""}`,
                   // What the title's words said, so nothing is read without being seen.
                   ...(r.read ? [`${r.read} --literal keeps the words in the title.`] : []),
@@ -2776,7 +2968,7 @@ export async function run(argv, io = {}) {
                   ...(values.due ? pilotLines(r, r.created) : []),
                   ...(r.created.milestone ? [`Toward the milestone ${r.created.milestone}.`] : []),
                   ...(r.milestoneReopened ? [`${r.milestoneReopened} is open again: it has an open task now.`] : []),
-                ].join("\n"),
+                    ].join("\n"),
               )
               .join("\n"),
           ),
@@ -3514,6 +3706,210 @@ export async function run(argv, io = {}) {
           `Saved “${r.template.name}” as a template in ${r.template.project}. harbor add --project "${r.template.project}" --template "${r.template.name}" starts a task from it.`,
       );
     }
+    case "milestones": {
+      const { positionals, values, harbor } = parse(spec(["done"], ["project", "program"]));
+      const program = values.program ?? (positionals.join(" ").trim() || undefined);
+      if (program && values.project) throw new HarborError("Say a program or --project, not both.");
+      return call(
+        "list_milestones",
+        { harbor, program, project: values.project, done: Boolean(values.done) },
+        milestonesText,
+      );
+    }
+    case "milestone": {
+      const { positionals, values, harbor } = parse(
+        spec(
+          ["new", "reached", "open", "approve"],
+          ["program", "due", "rename", "signs-off", "changes"],
+        ),
+      );
+      const name = text(positionals, "the milestone");
+      if (values.reached && values.open) throw new HarborError("Say --reached or --open, not both.");
+      const changes =
+        values.new ||
+        values.reached ||
+        values.open ||
+        values.approve ||
+        ["due", "rename", "signs-off", "changes"].some((k) => values[k] !== undefined);
+      if (!changes) {
+        // Reading one: the program's (or harbor's) milestones, reached ones too.
+        const r = await client.call("list_milestones", { harbor, program: values.program, done: true });
+        const want = name.toLowerCase();
+        const same = r.milestones.filter((m) => m.name.toLowerCase() === want);
+        const near = same.length ? same : r.milestones.filter((m) => m.name.toLowerCase().includes(want));
+        if (near.length !== 1)
+          throw new HarborError(
+            near.length
+              ? `"${name}" could be ${near.map((m) => `${m.name} (${m.program})`).join(" or ")}. Say --program.`
+              : `No milestone matches "${name}". harbor milestones lists them.`,
+          );
+        out(asJson ? jsonText({ milestone: near[0] }) : plain(milestoneLine(near[0])));
+        return 0;
+      }
+      const due = values.due === undefined ? undefined : dueDate(values.due);
+      return call(
+        "set_milestone",
+        {
+          harbor,
+          milestone: name,
+          program: values.program,
+          new: Boolean(values.new),
+          name: values.rename,
+          due,
+          reached: values.reached ? true : values.open ? false : undefined,
+          signOff: values["signs-off"],
+          approve: values.approve || undefined,
+          changes: values.changes,
+        },
+        (r) => (r.added ? `Added to ${r.added.program}: ${milestoneLine(r.added, { program: false })}` : milestoneLine(r.milestone)),
+      );
+    }
+    case "goal": {
+      const { positionals, values, harbor } = parse(
+        spec(
+          ["new"],
+          ["portfolio", "title", "owner", "due", "starts", "why", "link", "unlink", "kr", "at", "target", "start", "unit", "counts"],
+        ),
+      );
+      const ref = text(positionals, "the goal");
+      const num = (flag) => {
+        if (values[flag] === undefined) return undefined;
+        const n = Number(String(values[flag]).replace(/,/g, ""));
+        if (!Number.isFinite(n) || String(values[flag]).trim() === "")
+          throw new HarborError(`--${flag} is a number, like 12 or 2.5.`);
+        return n;
+      };
+      const list = (flag) =>
+        values[flag] === undefined
+          ? undefined
+          : String(values[flag])
+              .split(",")
+              .map((x) => x.trim())
+              .filter(Boolean);
+      const day = (flag) =>
+        values[flag] === undefined ? undefined : /^none$/i.test(values[flag]) ? "none" : dueDate(values[flag]);
+      if (values.new) {
+        if (values.kr && (values.at !== undefined || values.counts === undefined) && values.target === undefined)
+          throw new HarborError("A new number key result needs --target N (or --counts WORK for work).");
+        return call(
+          "set_goal",
+          {
+            harbor,
+            portfolio: values.portfolio,
+            title: ref,
+            owner: values.owner,
+            due: day("due") === "none" ? undefined : day("due"),
+            why: values.why,
+            keyResults: values.kr
+              ? [
+                  values.counts !== undefined
+                    ? { title: values.kr, kind: "work", counts: list("counts") }
+                    : { title: values.kr, kind: "number", start: num("start"), target: num("target"), unit: values.unit },
+                ]
+              : [],
+          },
+          (r) => `Set on ${r.goal.portfolio}: ${r.goal.title} (${r.goal.progress}).${r.goal.keyResults.length ? "" : ` Add a key result with harbor goal "${r.goal.title}" --kr "TITLE" --target N.`}`,
+        );
+      }
+      // The goal as Harbor has it, for its id and key results.
+      const goals = await client.call("list_goals", { harbor, ...(values.portfolio ? { portfolio: values.portfolio } : {}) });
+      const all = (goals.portfolios ?? []).flatMap((pf) => (pf.goals ?? []).map((g) => ({ pf, g })));
+      const want = ref.trim().toLowerCase();
+      const exact = all.filter((x) => x.g.title.trim().toLowerCase() === want || x.g.id === ref);
+      const near = exact.length ? exact : all.filter((x) => x.g.title.toLowerCase().includes(want));
+      if (near.length !== 1)
+        throw new HarborError(
+          near.length
+            ? `"${ref}" could be ${near.map((x) => `"${x.g.title}" (${x.pf.name})`).join(" or ")}. Say more of it, or --portfolio.`
+            : `No goal matches "${ref}".${all.length ? ` harbor goals lists them.` : ` Set one with harbor goal "TITLE" --new.`}`,
+        );
+      const { pf, g } = near[0];
+      const edits = ["title", "owner", "due", "starts", "why", "link", "unlink"].some((k) => values[k] !== undefined);
+      if (!values.kr && !edits) {
+        out(asJson ? jsonText({ goal: g, portfolio: pf.name }) : plain(goalText(g, pf.name)));
+        return 0;
+      }
+      if (!values.kr && ["at", "target", "start", "unit", "counts"].some((k) => values[k] !== undefined))
+        throw new HarborError('Say which key result with --kr "TITLE".');
+      const results = [];
+      if (edits)
+        results.push(
+          await client.call("edit_goal", {
+            harbor,
+            goal: g.id,
+            title: values.title,
+            owner: values.owner,
+            due: day("due"),
+            starts: day("starts"),
+            why: values.why,
+            link: list("link"),
+            unlink: list("unlink"),
+          }),
+        );
+      if (values.kr) {
+        const kr = g.keyResults.find((k) => k.title.trim().toLowerCase() === values.kr.trim().toLowerCase());
+        const shape = ["target", "start", "unit"].some((k) => values[k] !== undefined);
+        if (!kr) {
+          if (values.at !== undefined && !shape)
+            throw new HarborError(
+              `"${g.title}" has no key result "${values.kr}"${g.keyResults.length ? ` (it has ${g.keyResults.map((k) => `"${k.title}"`).join(", ")})` : ""}. --target N adds one.`,
+            );
+          if (values.counts === undefined && values.target === undefined)
+            throw new HarborError("A new key result needs --target N for a number, or --counts WORK to count work.");
+          results.push(
+            await client.call("set_goal", {
+              harbor,
+              portfolio: pf.name,
+              goal: g.id,
+              keyResults: [
+                values.counts !== undefined
+                  ? { title: values.kr, kind: "work", counts: list("counts") }
+                  : { title: values.kr, kind: "number", start: num("start"), target: num("target"), unit: values.unit },
+              ],
+            }),
+          );
+        } else {
+          if (shape || values.counts !== undefined)
+            results.push(
+              await client.call("edit_goal", {
+                harbor,
+                goal: g.id,
+                keyResult: { ref: kr.id, start: num("start"), target: num("target"), unit: values.unit },
+                ...(values.counts !== undefined ? { link: list("counts") } : {}),
+              }),
+            );
+          if (values.at !== undefined) {
+            if (kr.kind !== "number")
+              throw new HarborError(`"${kr.title}" counts work, so it moves as its tasks finish.`);
+            results.push(
+              await client.call("update_key_result", { harbor, goal: g.id, keyResult: kr.id, value: num("at") }),
+            );
+          }
+          if (values.at === undefined && !shape && values.counts === undefined)
+            throw new HarborError(`Say what to do with "${kr.title}": --at N, or --target N to change its numbers.`);
+        }
+      }
+      const last = results.at(-1);
+      const goal = last.goal;
+      if (asJson) out(jsonText(last));
+      else
+        out(
+          plain(
+            [
+              `${goal.title}: ${goal.progress}${goal.owner !== undefined ? ` · ${goal.owner ?? "nobody"}` : ""}${goal.due ? ` · by ${goal.due}` : ""}.`,
+              ...(last.keyResult
+                ? [`  ${last.keyResult.title} · ${last.keyResult.text}`]
+                : (goal.keyResults ?? []).map((k) => `  ${k.title} · ${k.text}`)),
+            ].join("\n"),
+          ),
+        );
+      return 0;
+    }
+    case "reports": {
+      const { positionals, harbor } = parse(spec());
+      const dashboard = positionals.join(" ").trim();
+      return call("list_dashboards", { harbor, ...(dashboard ? { dashboard } : {}) }, reportsText);
+    }
     case "goals": {
       const { positionals, harbor } = parse(spec());
       const portfolio = positionals.join(" ").trim();
@@ -3610,13 +4006,25 @@ export async function run(argv, io = {}) {
       return call("get_voyage_log", { harbor, project }, voyageText, voyageForTerminal);
     }
     case "messages": {
-      const { positionals, values, harbor } = parse(spec([], ["limit"]));
+      const { positionals, values, harbor } = parse(spec([], ["limit", "edit", "message"]));
       const [project, ...words] = positionals;
       if (!project)
         throw new HarborError(
           'Give a project, and a message if you\'re writing one: harbor messages "NAME" "TEXT".',
         );
       const body = words.join(" ").trim();
+      if (values.edit !== undefined || values.message !== undefined) {
+        const edit = (values.edit ?? "").trim() || body;
+        if (!edit) throw new HarborError('Say the new words: harbor messages "NAME" --edit "TEXT".');
+        if (values.edit && body) throw new HarborError("Give the new words once, after --edit.");
+        if (values.limit) throw new HarborError("--limit is for reading; leave it off when you edit.");
+        return call(
+          "edit_message",
+          { harbor, project, body: edit, ...(values.message ? { message: values.message } : {}) },
+          (r) =>
+            `Changed your message in ${r.edited.project}${r.mentioned?.length ? `; told ${r.mentioned.join(", ")}` : ""}.`,
+        );
+      }
       if (body) {
         if (values.limit)
           throw new HarborError("--limit is for reading; leave it off when you write.");