@harborppm/cli 0.97.0 → 0.98.0

package/dist/app.mjs

@@ -3376,7 +3376,7 @@ var init_thanks = __esmMin((() => {
 // src/lib/charter-lines.ts
 /** Nothing written on any of the five lines. */
 function charterEmpty(charter) {
-	return !charter || CHARTER_FIELDS.every((f) => !clean(charter[f]));
+	return !charter || CHARTER_FIELDS.every((f) => !clean$1(charter[f]));
 }
 /**
 * The charter after a change to some of its lines: trimmed, and null once
@@ -3396,7 +3396,7 @@ function withCharter(current, patch, by, at) {
 	}
 	return charterEmpty(next) ? null : next;
 }
-var CHARTER_FIELDS, clean;
+var CHARTER_FIELDS, clean$1;
 var init_charter_lines = __esmMin((() => {
 	CHARTER_FIELDS = [
 		"why",
@@ -3405,7 +3405,7 @@ var init_charter_lines = __esmMin((() => {
 		"doneWhen",
 		"callsBy"
 	];
-	clean = (s) => (s ?? "").replace(/\s+/g, " ").trim();
+	clean$1 = (s) => (s ?? "").replace(/\s+/g, " ").trim();
 }));
 
 // src/lib/charter.ts
@@ -3434,7 +3434,7 @@ function charterLines(charter) {
 	return CHARTER_FIELDS.map((field) => ({
 		field,
 		label: CHARTER_LABEL[field],
-		text: clean(charter[field])
+		text: clean$1(charter[field])
 	})).filter((l) => l.text);
 }
 function charterFilled(charter) {
@@ -3502,7 +3502,7 @@ function charterCheck(charter, tasks) {
 		};
 	});
 	return {
-		doneWhen: clean(charter.doneWhen) || null,
+		doneWhen: clean$1(charter.doneWhen) || null,
 		delivered,
 		crept: outOfScope(charter, tasks),
 		outItems: charterItems(charter.outScope).length
@@ -3524,6 +3524,18 @@ function charterSentence(check) {
 	return `Against the charter: ${bits.join("; ")}.`;
 }
 
+// src/lib/finished-on.ts
+/**
+* When the project was marked Done: its last move to Done in its health
+* history, else its last finished task, else its end date. Kept on its own so
+* the inbox can ask it without the voyage log's code.
+*/
+function finishedOn(project, tasks) {
+	const marked = [...project.healthHistory ?? []].reverse().find((h) => h.health === "done");
+	if (marked) return marked.at.slice(0, 10);
+	return (tasks.map((t) => t.completedAt).filter((x) => Boolean(x)).sort().at(-1) ?? project.endDate).slice(0, 10);
+}
+
 // src/lib/voyage-log.ts
 init_date_fns();
 init_blockers();
@@ -3531,12 +3543,6 @@ init_date_text();
 init_premortem();
 const day$8 = (iso) => parseIso(localDay(iso));
 const between = (a, b) => differenceInCalendarDays(day$8(b), day$8(a));
-/** When the project was marked Done: its last move to Done in its health history. */
-function finishedOn(project, tasks) {
-	const marked = [...project.healthHistory ?? []].reverse().find((h) => h.health === "done");
-	if (marked) return marked.at.slice(0, 10);
-	return (tasks.map((t) => t.completedAt).filter((x) => Boolean(x)).sort().at(-1) ?? project.endDate).slice(0, 10);
-}
 function voyageLog(data, projectId) {
 	const project = data.projects.find((p) => p.id === projectId);
 	if (!project) return null;
@@ -10560,6 +10566,126 @@ function HistoryView({ active, width, height, go }) {
 	});
 }
 
+// src/lib/landfall-lines.ts
+function isLandfallDays(n) {
+	return LANDFALL_DAYS.includes(n);
+}
+/** Why a landfall can't be saved as given, in words for the person; null when it can. */
+function landfallProblem(input) {
+	const expect = clean(input.expect);
+	if (!expect) return "Say what landfall should look like.";
+	if (expect.length > 300) return `Keep it under ${300} characters.`;
+	if (!isLandfallDays(input.afterDays)) return "Pick 30, 90 or 180 days.";
+	if (clean(input.measure).length > 60) return `Name the number in under ${60} characters.`;
+	return null;
+}
+/** Why an answer can't be saved as given; null when it can. */
+function landfallAnswerProblem(input) {
+	if (!LANDFALL_RESULTS.includes(input.result)) return "Say yes, partly or no.";
+	if (input.value != null && (typeof input.value !== "number" || !Number.isFinite(input.value))) return "The number has to be a number.";
+	if (typeof input.value === "number" && Math.abs(input.value) > 0xe8d4a51000) return "That number is too big.";
+	if (clean(input.note).length > 500) return `Keep the note under ${500} characters.`;
+	return null;
+}
+/**
+* The landfall after someone sets or changes what it looks like. An answer
+* already given stays: changing the words after the fact doesn't unask it.
+* Throws on bad input, so callers check `landfallProblem` first.
+*/
+function withLandfall(current, input, by, at) {
+	const problem = landfallProblem(input);
+	if (problem) throw new Error(problem);
+	const measure = clean(input.measure);
+	return {
+		...current ?? {},
+		expect: clean(input.expect),
+		afterDays: input.afterDays,
+		measure: measure || null,
+		setAt: current?.setAt ?? at,
+		setById: current?.setById ?? by
+	};
+}
+/** The landfall with an answer, or with the answer taken back (null) so it asks again. */
+function withLandfallAnswer(current, answer, by, at) {
+	if (!answer) {
+		const { result: _r, value: _v, note: _n, answeredAt: _a, answeredById: _b, ...rest } = current;
+		return rest;
+	}
+	const problem = landfallAnswerProblem(answer);
+	if (problem) throw new Error(problem);
+	const note = clean(answer.note);
+	return {
+		...current,
+		result: answer.result,
+		value: answer.value ?? null,
+		note: note || null,
+		answeredAt: at,
+		answeredById: by
+	};
+}
+var LANDFALL_DAYS, LANDFALL_EXPECT_MAX, LANDFALL_MEASURE_MAX, LANDFALL_NOTE_MAX, LANDFALL_RESULTS, clean;
+var init_landfall_lines = __esmMin((() => {
+	LANDFALL_DAYS = [
+		30,
+		90,
+		180
+	];
+	LANDFALL_EXPECT_MAX = 300;
+	LANDFALL_MEASURE_MAX = 60;
+	LANDFALL_NOTE_MAX = 500;
+	LANDFALL_RESULTS = [
+		"yes",
+		"partly",
+		"no"
+	];
+	clean = (s) => (s ?? "").replace(/\s+/g, " ").trim();
+}));
+
+// src/lib/landfall.ts
+init_date_fns();
+init_date_text();
+function plusDays(iso, days) {
+	return addDays(parseIso(iso.slice(0, 10)), days).toISOString().slice(0, 10);
+}
+/** The day to look: that many days after the project was marked Done. */
+function landfallCheckOn(project, tasks) {
+	if (!project.landfall) return null;
+	return plusDays(finishedOn(project, tasks), project.landfall.afterDays);
+}
+function landfallState(project, tasks, today) {
+	const lf = project.landfall;
+	if (lf?.result) return "answered";
+	if (project.health !== "done") return "sailing";
+	if (!lf) return "unset";
+	const on = landfallCheckOn(project, tasks);
+	return on && on <= today ? "due" : "waiting";
+}
+/** Who is asked: the project's owner, else (their person gone) the program's. */
+function landfallAskee(data, project) {
+	const here = (id) => id ? data.people.find((p) => p.id === id) : void 0;
+	return here(project.ownerId) ?? here(data.programs.find((p) => p.id === project.programId)?.ownerId);
+}
+/** A project's landfall as agents and the CLI's --json read it; null while there's none. */
+function landfallJson(project, tasks, today, people) {
+	const lf = project.landfall;
+	if (!lf) return null;
+	const answered = Boolean(lf.result);
+	return {
+		expect: lf.expect,
+		afterDays: lf.afterDays,
+		measure: lf.measure ?? null,
+		state: landfallState(project, tasks, today),
+		checkOn: project.health === "done" ? landfallCheckOn(project, tasks) : null,
+		result: lf.result ?? null,
+		...answered ? {
+			value: lf.value ?? null,
+			note: lf.note ?? null,
+			answeredOn: lf.answeredAt?.slice(0, 10) ?? null,
+			answeredBy: people.find((p) => p.id === lf.answeredById)?.name ?? null
+		} : {}
+	};
+}
+
 // src/lib/project-messages.ts
 /** This project's messages, oldest first. */
 function messagesOf(reflections, projectId) {
@@ -10682,6 +10808,7 @@ const KIND_RANK = {
 	waiting: 0,
 	approval: 1,
 	review: 2,
+	landfall: 2.5,
 	sounding: 3,
 	assigned: 4,
 	idle: 5,
@@ -10694,6 +10821,7 @@ const PING_KIND_LABEL = {
 	waiting: "Waiting on you",
 	approval: "Sign-offs",
 	review: "Reviews due",
+	landfall: "Landfall",
 	sounding: "Soundings",
 	assigned: "Assigned to you",
 	idle: "Quiet blockers",
@@ -10827,6 +10955,41 @@ function inboxOf(data, personId, now = clockNow()) {
 			personId: null
 		});
 	}
+	const askSince = todayISO(subDays(now, 14));
+	for (const project of data.projects) {
+		if (project.health !== "done" && !project.landfall?.result) continue;
+		if (landfallAskee(data, project)?.id !== personId) continue;
+		const tasks = tasksOf(data.tasks, project.id);
+		const state = landfallState(project, tasks, today);
+		if (state === "unset") {
+			const finished = finishedOn(project, tasks);
+			if (finished < askSince) continue;
+			pings.push({
+				id: `landfall-set:${project.id}:${finished}`,
+				kind: "landfall",
+				title: `${project.name} is done. What should landfall look like?`,
+				detail: "Say what should be true in 30, 90 or 180 days, and Harbor asks you then.",
+				at: finished,
+				projectId: project.id,
+				landfall: "set",
+				personId: null,
+				href: `/projects/${project.id}?view=log`
+			});
+		} else if (state === "due") {
+			const on = landfallCheckOn(project, tasks);
+			pings.push({
+				id: `landfall:${project.id}:${on}`,
+				kind: "landfall",
+				title: `Did ${project.name} reach landfall?`,
+				detail: `“${project.landfall.expect}”`,
+				at: on,
+				projectId: project.id,
+				landfall: "check",
+				personId: null,
+				href: `/projects/${project.id}?view=log`
+			});
+		}
+	}
 	for (const constraint of constraintsOwnedBy(data, personId)) {
 		if (!constraintIdle(data, constraint)) continue;
 		const program = data.programs.find((p) => p.id === constraint.programId);
@@ -22828,7 +22991,7 @@ const HARBOR_TOOLS = [
 	tool({
 		name: "get_project",
 		title: "Project details",
-		description: "One project: health and why, dates, budget, task counts, late tasks, what it waits on, milestones and open risks, when it will likely finish at the crew's recent pace (finish: shortHistory when there's under two weeks of it; lastDue names the open task whose due date the dates wait for, when the pace alone would finish sooner), notes the crew left for later (notesForLater: a sealed one shows only who left it and what opens it, unless it's the person's own), its charter (why, in, out, doneWhen, callsBy; null until someone writes one, and outOfScope lists open tasks whose titles name something it leaves out), the project's own task fields (fields: name, type and options, when it has any), and its url on the website." + DATA_NOTE,
+		description: "One project: health and why, dates, budget, task counts, late tasks, what it waits on, milestones and open risks, when it will likely finish at the crew's recent pace (finish: shortHistory when there's under two weeks of it; lastDue names the open task whose due date the dates wait for, when the pace alone would finish sooner), notes the crew left for later (notesForLater: a sealed one shows only who left it and what opens it, unless it's the person's own), its charter (why, in, out, doneWhen, callsBy; null until someone writes one, and outOfScope lists open tasks whose titles name something it leaves out), its landfall (what should be true some days after it's Done, when Harbor asks, and the answer: yes, partly or no with a number; null until someone sets one; state is sailing while not Done, unset, waiting, due or answered), the project's own task fields (fields: name, type and options, when it has any), and its url on the website." + DATA_NOTE,
 		input: object({
 			harbor: harborArg,
 			project: string().min(1).max(200).describe("Project id or name.")
@@ -22892,6 +23055,7 @@ const HARBOR_TOOLS = [
 				...p.customFields?.length ? { fields: fieldDefsOut(p) } : {},
 				finish: finishForecast(p, tasks, ctx.now, spendEntriesOf(data, p.id), data),
 				...charterOf(p, tasks),
+				landfall: landfallJson(p, tasks, today, data.people),
 				...notesOf(ctx, p),
 				...hillOf(p, today),
 				...webLink(ctx, { project: p.id })
@@ -25068,6 +25232,20 @@ function hierarchySlice({ get, write }) {
 				charter: withCharter(p.charter, patch, by, stamp())
 			} : p) });
 		},
+		setLandfall: (projectId, input) => {
+			const by = get().currentUserId;
+			write({ projects: get().projects.map((p) => p.id === projectId ? {
+				...p,
+				landfall: input ? withLandfall(p.landfall, input, by, stamp()) : null
+			} : p) });
+		},
+		answerLandfall: (projectId, answer) => {
+			const by = get().currentUserId;
+			write({ projects: get().projects.map((p) => p.id === projectId && p.landfall ? {
+				...p,
+				landfall: withLandfallAnswer(p.landfall, answer, by, stamp())
+			} : p) });
+		},
 		addCustomField: (projectId, def) => {
 			const id = uid("cf");
 			write({ projects: get().projects.map((p) => p.id === projectId ? {
@@ -25429,6 +25607,7 @@ var init_hierarchy = __esmMin((() => {
 	init_scuttle_rows();
 	init_hill();
 	init_charter_lines();
+	init_landfall_lines();
 	init_format();
 	init_empty();
 	init_first_week();

package/lib/cli.mjs

@@ -35,6 +35,7 @@ import {
   notesText,
   messagesText,
   charterText,
+  landfallText,
   daysText,
   soundingText,
   lifeboatsText,
@@ -263,6 +264,11 @@ export const HELP = `harbor: Harbor from the terminal
                                               a project's five-line charter
                                               (why, in, out, done when, who
                                               makes the calls): read or set
+  harbor landfall PROJECT [--expect T] [--after 30|90|180] [--measure T]
+                          [--answer yes|partly|no] [--value N] [--note T]
+                                              did a Done project pay off? say
+                                              what should be true, and answer
+                                              on the day
   harbor note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]
                                               a note for later: sealed until
                                               its day, milestone, or Off track
@@ -1025,6 +1031,24 @@ const DETAIL = {
     "  --no-people. A task already in its project is left alone: by its key",
     "  (a Key column, as harbor export writes) or by title.",
   ],
+  landfall: [
+    "  harbor landfall PROJECT                reads its landfall: what should be",
+    "                                         true some days after it's Done,",
+    "                                         when Harbor asks, and the answer",
+    "  Say what landfall looks like:",
+    '    --expect "TEXT"      what should be true by then',
+    "    --after 30|90|180    days after the project is marked Done to look",
+    "                         (90 unless you say)",
+    '    --measure "TEXT"     what the number counts, if there is one',
+    "  Answer it (on its day, or sooner):",
+    "    --answer yes|partly|no",
+    "    --value N            the number on the day",
+    '    --note "TEXT"        what you found',
+    "  --clear takes the landfall off (with --answer, only the answer), so it",
+    "  asks again. The owner is asked in their Inbox on the day; the portfolio",
+    "  counts the voyages that paid off. PROJECT is a name, a key like RR, or",
+    "  an id.",
+  ],
   charter: [
     "  harbor charter PROJECT                 reads its charter, and any open task",
     "                                         that names something it leaves out",
@@ -3286,6 +3310,70 @@ export async function run(argv, io = {}) {
           : `Cleared ${r.project}'s charter.`,
       );
     }
+    case "landfall": {
+      const { positionals, values, harbor } = parse(
+        spec(["clear"], ["expect", "after", "measure", "answer", "value", "note"]),
+      );
+      const project = one(positionals, 'project: harbor landfall "NAME"');
+      const answering =
+        values.answer !== undefined || values.value !== undefined || values.note !== undefined;
+      const setting =
+        values.expect !== undefined || values.after !== undefined || values.measure !== undefined;
+      if (answering && setting) {
+        throw new HarborError("Set the landfall or answer it, one at a time.");
+      }
+      const show = (r) => landfallText(r.project ?? r.name, r.landfall);
+      const json = (r) => ({ project: r.project ?? r.name, landfall: r.landfall ?? null });
+      if (answering || (values.clear && values.answer !== undefined)) {
+        if (values.clear) {
+          return call("answer_landfall", { harbor, project, clear: true }, show, json);
+        }
+        const result = String(values.answer ?? "").toLowerCase();
+        if (!["yes", "partly", "no"].includes(result)) {
+          throw new HarborError("Say --answer yes, partly or no.");
+        }
+        let value;
+        if (values.value !== undefined) {
+          value = Number(String(values.value).replace(/,/g, ""));
+          if (!Number.isFinite(value)) throw new HarborError("--value takes a number, like 120.");
+        }
+        return call(
+          "answer_landfall",
+          {
+            harbor,
+            project,
+            result,
+            ...(value !== undefined ? { value } : {}),
+            ...(values.note !== undefined ? { note: values.note } : {}),
+          },
+          show,
+          json,
+        );
+      }
+      if (values.clear) return call("set_landfall", { harbor, project, clear: true }, show, json);
+      if (setting) {
+        let afterDays;
+        if (values.after !== undefined) {
+          afterDays = Number(String(values.after).replace(/\s*days?$/i, ""));
+          if (![30, 90, 180].includes(afterDays)) {
+            throw new HarborError("--after takes 30, 90 or 180 (days after the project is Done).");
+          }
+        }
+        return call(
+          "set_landfall",
+          {
+            harbor,
+            project,
+            ...(values.expect !== undefined ? { expect: values.expect } : {}),
+            ...(afterDays !== undefined ? { afterDays } : {}),
+            ...(values.measure !== undefined ? { measure: values.measure } : {}),
+          },
+          show,
+          json,
+        );
+      }
+      return call("get_project", { harbor, project }, show, json);
+    }
     case "sound": {
       const { positionals, values, harbor } = parse(spec([], ["answer", "why", "ask", "settle"]));
       const [task, ...extra] = positionals;

package/lib/format.mjs

@@ -815,6 +815,34 @@ export function charterText(r) {
   return lines.join("\n");
 }
 
+const LANDFALL_RESULT = { yes: "Paid off", partly: "Partly", no: "Didn't" };
+
+/** A project's landfall as get_project, set_landfall or answer_landfall gives it. */
+export function landfallText(project, lf) {
+  if (!lf) {
+    return `${project} has no landfall yet. Say what should be true some days after it's Done:\n  harbor landfall "${project}" --expect "…" --after 90 [--measure "weekly sign-ups"]`;
+  }
+  const lines = [`Landfall · ${project}`, `  Looks like  ${lf.expect}`];
+  if (lf.measure) lines.push(`  Counting    ${lf.measure}`);
+  if (lf.result) {
+    const value =
+      lf.value != null ? ` · ${Number(lf.value).toLocaleString("en-US")}${lf.measure ? ` ${lf.measure}` : ""}` : "";
+    lines.push(`  Answer      ${LANDFALL_RESULT[lf.result] ?? lf.result}${value}`);
+    if (lf.note) lines.push(`              ${lf.note}`);
+    if (lf.answeredOn)
+      lines.push(`              said by ${lf.answeredBy ?? "someone"} on ${lf.answeredOn}`);
+  } else if (lf.state === "due") {
+    lines.push(
+      `  Due now     its day was ${lf.checkOn}. Answer: harbor landfall "${project}" --answer yes|partly|no [--value N]`,
+    );
+  } else if (lf.state === "waiting") {
+    lines.push(`  Check on    ${lf.checkOn} (${lf.afterDays} days after Done)`);
+  } else {
+    lines.push(`  Check       ${lf.afterDays} days after the project is marked Done`);
+  }
+  return lines.join("\n");
+}
+
 export function notesText(project, notes) {
   if (!notes?.length)
     return `No notes for later on ${project}. Leave one: harbor note "${project}" "NOTE" --opens +30`;

package/package.json

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