@harborppm/cli 0.59.0 → 0.61.0

package/lib/cli.mjs

@@ -39,9 +39,12 @@ import {
   lifeboatsText,
   followedText,
   soundingsText,
+  thanksText,
   ashoreText,
   voyageText,
   whyText,
+  bridgeText,
+  barnaclesText,
   handoverText,
   fogText,
   agentWorkText,
@@ -97,6 +100,9 @@ export const HELP = `harbor: Harbor from the terminal
                                               changes without --apply
   harbor why PROJECT|TASK|MILESTONE           what's holding it up: the line of
                                               task waits that sets its date
+  harbor barnacles PROJECT                    work added since the plan was set:
+                                              by week, by who, and the days of
+                                              slip it explains
   harbor hill [--program P]                   where each project is on its hill
   harbor hill PROJECT --at 0-100|top|done     move it: up to 50 is figuring it
                                               out, past 50 is getting it done
@@ -184,10 +190,17 @@ export const HELP = `harbor: Harbor from the terminal
                                               the review: programs worst first,
                                               each with its next move (reads
                                               only; harbor submit moves a task)
+  harbor thanks [--all] [--given]             thanks you were given this month
+  harbor thanks TASK "LINE" [--to NAME]       a one-line thanks for a task
+  harbor thanks --milestone NAME|--decision TITLE "LINE" [--to NAME]
+                                              the same for a milestone or a
+                                              decision
   harbor bridge [--harbor H]                  run the review as a meeting: one
                                               project a screen, what changed
                                               since the last one, decisions,
                                               actions and risks logged live
+  harbor bridge --list [--program P]          what changed since the last
+                                              review, as text (or --json)
   harbor next-move PROGRAM "TEXT"             write a program's next move
   harbor health --program P|--project P|--portfolio P STATE [--note WHY]
                                               set its health by hand, or auto
@@ -235,6 +248,8 @@ export const HELP = `harbor: Harbor from the terminal
   harbor fog keep TASK                        it's still needed: out of the fog
   harbor watch [--project P] [--bell]         a live ticker of the harbor's
                                               changes; yours bright, q stops
+  harbor watch --once [--since TIME] [--json] the latest changes (or all since
+                                              TIME), printed once, for scripts
   harbor lifeboats [--program P]              work only one person knows, each
                                               with a second pair of hands
   harbor lifeboats N [--person NAME]          adds that second pair of hands
@@ -813,10 +828,18 @@ const DETAIL = {
     "                                         cards moving, comments, health changes",
     "    --project P     one project's changes only",
     "    --bell          ring the terminal's bell when something of yours changes",
+    "    --since TIME    start with every change since TIME (14:30 today, or",
+    "                    2026-10-21, or 2026-10-21T14:30) instead of the last 5",
+    "    --once          print those and stop instead of listening",
+    "    --json          one JSON object a line (at, text, quote, mine, tone;",
+    "                    earlier: true for the ones from before it started)",
     "",
-    "  Lines about your own work (your tasks, mentions of you, what you lead) are",
-    "  bright; the rest are dim. q or Ctrl+C stops. Made for a narrow split or a",
-    "  tmux pane; it needs full access (harbor login without --read-only).",
+    "  It starts with the latest few changes and a \"since HH:MM\" line, then",
+    "  prints each new one as it lands. Lines about your own work (your tasks,",
+    "  mentions of you, what you lead) are bright; the rest are dim. It runs",
+    "  until q or Ctrl+C (or until it's killed, when piped or with --json);",
+    "  --once returns at once. Made for a narrow split or a tmux pane; it needs",
+    "  full access (harbor login without --read-only).",
   ],
   lifeboats: [
     "  harbor lifeboats [--program P]         reads: work only one person has",
@@ -873,9 +896,23 @@ const DETAIL = {
     "  Tasks have due dates, not lengths, so a task can finish on its due date",
     "  at the soonest, never before what it waits on, and never in the past.",
     "  Each link's slack is the days it can slip before it moves the next one",
-    "  (or the end); a negative one already does. PROJECT is a name, a key",
+    "  (or the end); a negative one already does. Open tasks with no due date",
+    "  can't hold a date, so they're left out and counted. In --json, endDate",
+    "  (dueDate for a task or milestone) is the date held and daysSpare the",
+    "  days before it (negative: that many over). PROJECT is a name, a key",
     "  like RR, or an id.",
   ],
+  barnacles: [
+    "  harbor barnacles PROJECT               reads how much the plan has grown",
+    "",
+    "  Counts the tasks made after the baseline was set (without a baseline",
+    "  time, after the project's first week of tasks), as a",
+    "  share of what was planned, by week and by who added them. At the",
+    "  crew's pace (tasks finished a week over the last six) it says how many",
+    "  days of work that is, and how much of the slip against the planned end",
+    "  it explains. The weekly brief names projects that grew a lot since",
+    "  their baseline.",
+  ],
   voyage: [
     "  harbor voyage PROJECT                  reads a Done project's voyage log",
     '  harbor voyage PROJECT "YOUR LINE"      writes: adds or changes your line in it',
@@ -909,19 +946,40 @@ const DETAIL = {
     "  enough of it to pick one out; harbor risks lists them. Changes several",
     "  at once, as one change.",
   ],
+  thanks: [
+    "  harbor thanks                          reads the thanks you were given in",
+    "                                         the last 30 days, newest first",
+    "  harbor thanks --all                    everyone's; --given: the ones you gave",
+    '  harbor thanks RR-42 "LINE"             writes: thanks whoever has the task',
+    '  harbor thanks --milestone NAME "LINE"  writes: thanks for a milestone (its',
+    "                                         sign-off person unless --to says)",
+    '  harbor thanks --decision TITLE "LINE"  writes: thanks whoever made the call',
+    "  --to NAME                              someone else instead",
+    "",
+    "  Fair winds: a thanks shows on the work, on the person's card on People,",
+    "  in the next brief and in the project's voyage log. Nobody can thank",
+    "  themselves, and nothing counts or ranks them.",
+  ],
   bridge: [
     "  harbor bridge                          opens the full-screen app on the",
     "                                         review meeting (b on the Programs",
     "                                         screen, or : Run the review meeting)",
+    "  harbor bridge --list [--program P]     prints the agenda instead: what",
+    "                                         changed on each project since its",
+    "                                         program's last review, every item",
+    "                                         (--json for scripts and agents; the",
+    "                                         same when piped). Reading it doesn't",
+    "                                         count as holding the meeting",
     "",
     "  One open project a screen, with only what changed since its program was",
     "  last reviewed (a week back the first time): health moves, work finished,",
     "  newly late or added, risks raised, decisions made. ←→ move between",
     "  projects; d logs a decision, a an action (who takes it, due in a week),",
-    "  r a risk, m the program's next move; e ends it. The summary lists what",
-    "  was logged; p posts it to each program's chat channel where one is set",
-    "  (Ship to shore, set on the website), y copies it. The next meeting",
-    "  counts from when this one ended.",
+    "  r a risk, m the program's next move, v shows every item behind an",
+    "  \"and N more\" (↑↓ scroll); e ends it, Esc or q leaves without ending",
+    "  it. The summary lists what was logged; p posts it to each program's",
+    "  chat channel where one is set (Ship to shore, set on the website), y",
+    "  copies it. The next meeting counts from when this one ended.",
   ],
   review: [
     "  harbor review                          reads the review: every program,",
@@ -1146,8 +1204,14 @@ export async function run(argv, io = {}) {
   }
 
   // On its own in a terminal: the full-screen app. Piped or scripted: the help.
-  if (!command || command === "app" || command === "bridge") {
-    const terminal = io.terminal ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  const inTerminal = io.terminal ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  // harbor bridge --list (or --json, or piped) prints the agenda through the commands below.
+  const bridgeApp =
+    command === "bridge" &&
+    inTerminal &&
+    !rest.some((a) => a === "--list" || a === "--json" || a.startsWith("--program"));
+  if (!command || command === "app" || bridgeApp) {
+    const terminal = inTerminal;
     if (!command && !terminal) {
       out(HELP);
       return 0;
@@ -2624,6 +2688,12 @@ export async function run(argv, io = {}) {
       if (!of) throw new HarborError("Say what: a project, a task key like RR-42, or a milestone.");
       return call("long_pole", { harbor, of }, whyText);
     }
+    case "barnacles": {
+      const { positionals, harbor } = parse(spec());
+      const project = positionals.join(" ").trim();
+      if (!project) throw new HarborError("Say which project: harbor barnacles PROJECT.");
+      return call("scope_growth", { harbor, project }, barnaclesText);
+    }
     case "voyage": {
       const { positionals, harbor } = parse(spec());
       const [project, ...words] = positionals;
@@ -2639,13 +2709,18 @@ export async function run(argv, io = {}) {
       return call("get_voyage_log", { harbor, project }, voyageText, voyageForTerminal);
     }
     case "watch": {
-      const { positionals, values, harbor } = parse(spec(["bell"], ["project"]));
+      const { positionals, values, harbor } = parse(spec(["bell", "once"], ["project", "since"]));
       none(positionals);
       if (!hasFullAccess(creds))
         throw new HarborError(
           "Watching needs full access, as the full-screen app does. Run harbor login (without --read-only), then try again.",
         );
-      const { watchHere } = await loadApp();
+      const { watchHere, watchSince } = await loadApp();
+      const since = values.since ? watchSince(values.since, new Date()) : null;
+      if (values.since && !since)
+        throw new HarborError(
+          `--since takes a time today (14:30) or a date (2026-10-21, or 2026-10-21T14:30), not "${values.since}".`,
+        );
       await watchHere({
         source: tokenSource({ creds, save: (c) => writeCredentials(c, env), fetcher }),
         fetcher,
@@ -2653,7 +2728,10 @@ export async function run(argv, io = {}) {
         saved: creds.harbor ?? null,
         project: values.project,
         bell: Boolean(values.bell),
-        colour: colourDepth(io.stdout ?? process.stdout, env) !== "none",
+        colour: !asJson && colourDepth(io.stdout ?? process.stdout, env) !== "none",
+        since,
+        once: Boolean(values.once),
+        json: asJson,
       });
       return 0;
     }
@@ -2692,6 +2770,49 @@ export async function run(argv, io = {}) {
       }
       return call("fog", { harbor, project: values.project, limit: 100 }, (r) => fogText(r));
     }
+    case "bridge": {
+      const { positionals, values, harbor } = parse(spec(["list"], ["program"]));
+      none(positionals);
+      return call("review_meeting", { harbor, program: values.program }, bridgeText);
+    }
+    case "thanks": {
+      const { positionals, values, harbor } = parse(
+        spec(["all", "given"], ["to", "milestone", "decision"]),
+      );
+      const forWork = values.milestone || values.decision;
+      if (!forWork && positionals.length === 0) {
+        return call(
+          "list_thanks",
+          {
+            harbor,
+            person: values.all ? "all" : "me",
+            given: Boolean(values.given),
+          },
+          thanksText,
+        );
+      }
+      const [first, ...rest] = positionals;
+      const task = forWork ? undefined : first;
+      const line = (forWork ? positionals : rest).join(" ").trim();
+      if (task && !TASK_KEY.test(task) && !line) {
+        throw new HarborError(
+          'Say what for and the line: harbor thanks RR-42 "Caught it before launch" (or --milestone NAME, --decision TITLE).',
+        );
+      }
+      if (!line) throw new HarborError('Add the line of thanks in quotes: harbor thanks RR-42 "Thank you".');
+      return call(
+        "give_thanks",
+        {
+          harbor,
+          task,
+          milestone: values.milestone,
+          decision: values.decision,
+          to: values.to,
+          line,
+        },
+        (r) => `Fair winds: thanked ${r.thanked.to ?? "them"} for ${r.thanked.for}.`,
+      );
+    }
     case "handover": {
       const { positionals, values, harbor } = parse(
         spec(["confirm"], ["to", "until", "note", "keep"]),

package/lib/format.mjs

@@ -526,15 +526,66 @@ export function premortemText(r, project = r.project) {
 }
 
 /** A project's voyage log, as get_voyage_log answers it. */
+/** `harbor thanks`: each thanks on two lines, the words first, no counts. */
+export function thanksText(r) {
+  if (r.note) return r.note;
+  if (!r.thanks.length) {
+    return r.person
+      ? `No thanks in the last ${r.days} days yet. harbor thanks TASK "LINE" gives one.`
+      : `Nobody has thanked anyone in the last ${r.days} days. harbor thanks TASK "LINE" gives one.`;
+  }
+  return r.thanks
+    .map((t) => `“${t.line}”\n  ${t.from} to ${t.to}, for ${t.for} · ${t.at.slice(0, 10)}`)
+    .join("\n");
+}
+
 export function voyageText(r) {
   const head = [`Voyage log · ${r.project}${r.done ? ` · Done ${r.finished}` : " · not Done yet"}`];
   if (r.note) head.push(r.note);
   head.push((r.stats ?? []).join(" · "));
   const story = (r.story ?? []).map((s) => `  - ${s}`);
   const crew = (r.crew ?? []).map((c) => `  - ${c.who ?? "Someone"}: ${c.line}`);
-  return [...head, "", ...story, ...(crew.length ? ["", "From the crew:", ...crew] : [])].join(
-    "\n",
+  const thanks = (r.thanks ?? []).map(
+    (t) => `  - ${t.from ?? "Someone"} to ${t.to ?? "someone"}: “${t.line}”`,
+  );
+  return [
+    ...head,
+    "",
+    ...story,
+    ...(thanks.length ? ["", "Fair winds along the way:", ...thanks] : []),
+    ...(crew.length ? ["", "From the crew:", ...crew] : []),
+  ].join("\n");
+}
+
+/** The review meeting's agenda, as review_meeting answers it: each project that moved, with every item. */
+export function bridgeText(r) {
+  const programs = r.programs ?? [];
+  if (programs.length === 0) return "No open programs to review.";
+  const out = programs.map(
+    (p) =>
+      `${p.name}: changes since ${p.lastReviewed ? "the last review" : "last week"}, ${p.since.slice(0, 10)}`,
   );
+  for (const p of r.projects ?? []) {
+    const facts = [
+      p.health,
+      p.lead,
+      p.ends ? `ends ${p.ends}` : null,
+      `${p.late} late of ${p.open} open`,
+      p.highRisks ? `${p.highRisks} high risk${p.highRisks === 1 ? "" : "s"}` : null,
+      p.nextMilestone ? `next milestone ${p.nextMilestone.name}, ${p.nextMilestone.due}` : null,
+    ].filter(Boolean);
+    out.push("", `${p.project} (${p.program})`, `  ${facts.join(" · ")}`);
+    for (const c of p.changes) {
+      if (c.items) {
+        out.push(`  - ${c.text.split(":")[0]} (${c.items.length}):`);
+        for (const item of c.items) out.push(`      ${item}`);
+      } else out.push(`  - ${c.text}`);
+    }
+  }
+  if ((r.projects ?? []).length === 0) out.push("", "Nothing moved since the last review.");
+  const quiet = (r.quiet ?? []).map((q) => q.project);
+  if (quiet.length) out.push("", `No change on ${quiet.join(", ")}.`);
+  return out.join("\n");
 }
 
 /** What's holding something up, as long_pole answers it: the headline, then the line of waits, first blocker at the top. */
@@ -571,7 +622,29 @@ export function whyText(r) {
           .join(", ")}.`,
       ]
     : [];
-  return [...head, "", ...via, ...lines, ...others].join("\n");
+  const note = r.note ? ["", r.note] : [];
+  return [...head, "", ...via, ...lines, ...others, ...note].join("\n");
+}
+
+/** A project's barnacles, as scope_growth answers it: the growth, its cost in days, by week and by who. */
+export function barnaclesText(r) {
+  const head = [`Barnacles · ${r.project}`];
+  if (!r.added) {
+    head.push(`Nothing added since the plan was set (${r.since.slice(0, 10)}): ${r.planned} task${r.planned === 1 ? "" : "s"}, as planned.`);
+    return head.join("\n");
+  }
+  head.push(`${r.headline} (${r.planned} planned, ${r.addedThisWeek} added this week).`);
+  if (r.daysLine) head.push(r.daysLine);
+  const top = Math.max(1, ...r.byWeek.map((w) => w.added));
+  const weeks = r.byWeek.map(
+    (w) => `  w/c ${w.weekOf}  ${"█".repeat(Math.max(1, Math.round((w.added / top) * 20)))} ${w.added}`,
+  );
+  const who = r.byWho.map((w) => `${w.who ?? "not recorded"} ${w.added}`).join(", ");
+  const from =
+    r.measuredFrom === "when the baseline was set"
+      ? `Counted from when the baseline was set, ${r.since.slice(0, 10)}.`
+      : `Counted from a week after its first task was made, ${r.since.slice(0, 10)}; setting a baseline counts from then instead.`;
+  return [...head, "", "Added by week:", ...weeks, "", `By who: ${who}`, "", from].join("\n");
 }
 
 /** A position on a 21-wide track, the top of the hill marked in the middle. */

package/lib/mcp.mjs

@@ -53,8 +53,15 @@ export function createClient({ creds, save, fetcher = fetch, now = Date.now }) {
       const msg = await res.json();
       if (msg.error) throw new HarborError(msg.error.message);
       const result = msg.result ?? {};
-      if (result.isError)
-        throw new HarborError(result.content?.map((c) => c.text).join("\n") || "Harbor said no.");
+      if (result.isError) {
+        const said = result.content?.map((c) => c.text).join("\n") || "Harbor said no.";
+        // A command newer than the site it talks to: the tool ships with the next deploy.
+        if (/^No tool named "/.test(said))
+          throw new HarborError(
+            `${new URL(current.server).host} doesn't have this yet. Try again after the next site update.`,
+          );
+        throw new HarborError(said);
+      }
       return result.structuredContent ?? JSON.parse(result.content?.[0]?.text ?? "{}");
     },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harborppm/cli",
-  "version": "0.59.0",
+  "version": "0.61.0",
   "description": "Harbor from the terminal: a full-screen app with everything, plus commands for scripts and agents.",
   "keywords": [
     "harbor",