@harborppm/cli 0.96.0 → 0.98.0

package/dist/app.mjs

@@ -2688,13 +2688,13 @@ var init_holidays = __esmMin((() => {
 // src/lib/tide.ts
 /** Tasks finished in each of the last weeks, oldest first. Done tasks without a date, or dated after now, count as finished now. */
 function weeklyFinished(tasks, startDate, now, weeks = 6) {
-	const today = noon$3(todayISO(now));
-	const age = Math.floor(differenceInCalendarDays(today, noon$3(startDate)) / 7) + 1;
+	const today = noon$4(todayISO(now));
+	const age = Math.floor(differenceInCalendarDays(today, noon$4(startDate)) / 7) + 1;
 	const span = Math.max(1, Math.min(weeks, age));
 	const counts = new Array(span).fill(0);
 	for (const t of tasks) {
 		if (t.status !== "done") continue;
-		const at = t.completedAt ? noon$3(t.completedAt) : today;
+		const at = t.completedAt ? noon$4(t.completedAt) : today;
 		const back = Math.max(0, differenceInCalendarDays(today, at));
 		const week = Math.floor(back / 7);
 		if (week < span) counts[span - 1 - week] += 1;
@@ -2872,7 +2872,7 @@ function tideOptions(data) {
 function tideForecast(project, tasks, now, opts = {}) {
 	if (tasks.length === 0) return { kind: "empty" };
 	const remaining = tasks.filter((t) => t.status !== "done").length;
-	if (remaining === 0) return { kind: "done" };
+	if (remaining === 0 || project.health === "done") return { kind: "done" };
 	if (project.health === "paused") return {
 		kind: "paused",
 		remaining
@@ -2885,7 +2885,7 @@ function tideForecast(project, tasks, now, opts = {}) {
 		finished
 	};
 	const today = todayISO(now);
-	const base = noon$3(today);
+	const base = noon$4(today);
 	const { shares, crew } = weekShares(tasks, base, opts.calendar);
 	const paced = simulate(remaining, weekly, hash(`${project.id}|${remaining}|${today}`), Math.max(0, opts.pace ?? 1), shares);
 	const at = (share, list = runs) => list[Math.min(list.length - 1, Math.ceil(share * list.length) - 1)];
@@ -2894,12 +2894,12 @@ function tideForecast(project, tasks, now, opts = {}) {
 		if (t.status === "done" || !t.dueDate) continue;
 		if (!lastDue || t.dueDate > lastDue.dueDate) lastDue = t;
 	}
-	const floor = lastDue ? differenceInCalendarDays(noon$3(lastDue.dueDate), base) : 0;
+	const floor = lastDue ? differenceInCalendarDays(noon$4(lastDue.dueDate), base) : 0;
 	const sounded = soundingFloors(tasks, opts.reflections, base, hash(`${project.id}|sound|${today}`), opts.calendar);
 	const runs = paced.map((d, i) => Math.max(d, floor, sounded.floors?.[i] ?? 0)).sort((a, b) => a - b);
 	const heldBy = lastDue && floor > at(.5, paced) ? lastDue : null;
 	const dayOf = (days) => Number.isFinite(days) ? todayISO(addDays(base, days)) : null;
-	const toEnd = differenceInCalendarDays(noon$3(project.endDate), base);
+	const toEnd = differenceInCalendarDays(noon$4(project.endDate), base);
 	const byEnd = runs.filter((d) => d <= toEnd).length / runs.length;
 	const last = Math.max(Number.isFinite(at(.99)) ? at(.99) : 728, toEnd + 14, 7);
 	const curve = [];
@@ -2952,7 +2952,7 @@ function tideQuiet(tide) {
 		default: return null;
 	}
 }
-var TIDE_WEEKS, TRIALS, MAX_WEEKS, ROUGH_BELOW, TIDE_MIN_FINISHED, noon$3;
+var TIDE_WEEKS, TRIALS, MAX_WEEKS, ROUGH_BELOW, TIDE_MIN_FINISHED, noon$4;
 var init_tide = __esmMin((() => {
 	init_date_fns();
 	init_format();
@@ -2963,7 +2963,7 @@ var init_tide = __esmMin((() => {
 	MAX_WEEKS = 104;
 	ROUGH_BELOW = 5;
 	TIDE_MIN_FINISHED = 3;
-	noon$3 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+	noon$4 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
 }));
 
 // src/lib/barnacles.ts
@@ -2980,7 +2980,7 @@ function planSetAt(project, tasks) {
 	for (const t of tasks) if (!first || t.createdAt < first) first = t.createdAt;
 	first = (first ?? project.startDate).slice(0, 10);
 	return {
-		since: `${isoDay$3(addDays(noon$2(first), 7))}T00:00:00`,
+		since: `${isoDay$3(addDays(noon$3(first), 7))}T00:00:00`,
 		from: "start"
 	};
 }
@@ -2992,20 +2992,20 @@ function planSetAt(project, tasks) {
 function barnaclesOf(project, tasks, people, now, slip = null) {
 	const { since, from } = planSetAt(project, tasks);
 	const today = todayISO(now);
-	const weekAgo = isoDay$3(addDays(noon$2(today), -7));
+	const weekAgo = isoDay$3(addDays(noon$3(today), -7));
 	let planned = 0;
 	const added = [];
 	for (const t of tasks) if (t.createdAt > since) added.push(t);
 	else planned += 1;
-	const first = startOfWeek(noon$2(since), { weekStartsOn: 1 });
-	const span = Math.max(0, Math.floor(differenceInCalendarDays(noon$2(today), first) / 7));
+	const first = startOfWeek(noon$3(since), { weekStartsOn: 1 });
+	const span = Math.max(0, Math.floor(differenceInCalendarDays(noon$3(today), first) / 7));
 	const weeks = Array.from({ length: Math.min(span + 1, 104) }, (_, i) => ({
 		week: isoDay$3(addDays(first, i * 7)),
 		added: 0
 	}));
 	const counts = /* @__PURE__ */ new Map();
 	for (const t of added) {
-		const i = Math.floor(differenceInCalendarDays(noon$2(t.createdAt), first) / 7);
+		const i = Math.floor(differenceInCalendarDays(noon$3(t.createdAt), first) / 7);
 		const slot = weeks[Math.min(Math.max(0, i), weeks.length - 1)];
 		if (slot) slot.added += 1;
 		const who = t.createdById ?? null;
@@ -3023,7 +3023,7 @@ function barnaclesOf(project, tasks, people, now, slip = null) {
 	const byDay = /* @__PURE__ */ new Map();
 	for (const t of added) byDay.set(t.createdAt.slice(0, 10), (byDay.get(t.createdAt.slice(0, 10)) ?? 0) + 1);
 	const [bulkDay, bulk] = [...byDay].sort((a, b) => b[1] - a[1])[0] ?? [null, 0];
-	const age = differenceInCalendarDays(noon$2(today), addDays(noon$2(since), -7)) / 7;
+	const age = differenceInCalendarDays(noon$3(today), addDays(noon$3(since), -7)) / 7;
 	let caveat = null;
 	if (added.length && bulkDay && bulk >= 5 && bulk >= added.length * .5) caveat = `${bulk} of the ${added.length} came in on ${shortDate(bulkDay)}, which looks like the plan being loaded rather than growth, so treat this as rough. Setting a baseline counts from then on.`;
 	else if (added.length && from === "start" && (planned < 5 || age < 3)) caveat = "There's no baseline yet and the plan is young, so its first weeks may be the plan being written: treat this as rough. Setting a baseline counts from then on.";
@@ -3050,8 +3050,8 @@ function barnaclesOf(project, tasks, people, now, slip = null) {
 */
 function slipAgainstPlan(project, tasks, now, tide = tideForecast(project, tasks, now)) {
 	const plannedEnd = (project.baselineEnd ?? project.endDate).slice(0, 10);
-	const likely = tide.kind === "forecast" && tide.likely ? differenceInCalendarDays(noon$2(tide.likely), noon$2(plannedEnd)) : 0;
-	const moved = project.baselineEnd ? differenceInCalendarDays(noon$2(project.endDate), noon$2(project.baselineEnd)) : 0;
+	const likely = tide.kind === "forecast" && tide.likely ? differenceInCalendarDays(noon$3(tide.likely), noon$3(plannedEnd)) : 0;
+	const moved = project.baselineEnd ? differenceInCalendarDays(noon$3(project.endDate), noon$3(project.baselineEnd)) : 0;
 	const slip = Math.max(likely, moved);
 	return slip > 0 ? slip : null;
 }
@@ -3084,7 +3084,7 @@ function barnaclesShort(b) {
 function briefWorthy(b) {
 	return b.from === "baseline" && !b.caveat && b.added >= 3 && (b.share == null || b.share >= .15);
 }
-var SETTLE_DAYS, THIN_PLANNED, THIN_WEEKS, BULK_SHARE, BULK_MIN, BRIEF_MIN_ADDED, BRIEF_MIN_SHARE, noon$2, isoDay$3, plural$7;
+var SETTLE_DAYS, THIN_PLANNED, THIN_WEEKS, BULK_SHARE, BULK_MIN, BRIEF_MIN_ADDED, BRIEF_MIN_SHARE, noon$3, isoDay$3, plural$7;
 var init_barnacles = __esmMin((() => {
 	init_date_fns();
 	init_format();
@@ -3096,7 +3096,7 @@ var init_barnacles = __esmMin((() => {
 	BULK_MIN = 5;
 	BRIEF_MIN_ADDED = 3;
 	BRIEF_MIN_SHARE = .15;
-	noon$2 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+	noon$3 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
 	isoDay$3 = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
 	plural$7 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 }));
@@ -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;
@@ -5942,18 +5948,18 @@ init_tide();
 const BURN_DAYS = 56;
 /** A window shorter than a week says too little to read a rate from. */
 const MIN_DAYS = 7;
-const noon$1 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+const noon$2 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
 /**
 * Spend a day over the last BURN_DAYS (or the project's life, when it's
 * younger), from the ledger; null when nothing was spent in that time.
 */
 function burnPerDay(entries, startDate, now) {
-	const today = noon$1(todayISO(now));
-	const age = differenceInCalendarDays(today, noon$1(startDate)) + 1;
+	const today = noon$2(todayISO(now));
+	const age = differenceInCalendarDays(today, noon$2(startDate)) + 1;
 	const span = Math.max(MIN_DAYS, Math.min(56, age));
 	let sum = 0;
 	for (const e of entries) {
-		const back = differenceInCalendarDays(today, noon$1(e.date));
+		const back = differenceInCalendarDays(today, noon$2(e.date));
 		if (back >= 0 && back < span) sum += e.amount;
 	}
 	return sum > 0 ? sum / span : null;
@@ -5975,8 +5981,8 @@ function slipCost(project, tide, entries, now) {
 	const from = project.endDate > today ? project.endDate : today;
 	const point = (date) => {
 		if (!date) return null;
-		const daysLate = Math.max(0, differenceInCalendarDays(noon$1(date), noon$1(from)));
-		const ahead = Math.max(0, differenceInCalendarDays(noon$1(date), noon$1(today)));
+		const daysLate = Math.max(0, differenceInCalendarDays(noon$2(date), noon$2(from)));
+		const ahead = Math.max(0, differenceInCalendarDays(noon$2(date), noon$2(today)));
 		return {
 			date,
 			daysLate,
@@ -10136,11 +10142,11 @@ function hillText(project) {
 	if (at === 100) return "Over the hill: done";
 	return `${HILL_PHASE_LABEL[hillPhase(at)]} (${at} of 100)`;
 }
-var HILL_TOP, STILL_DAYS, HILL_PHASE_LABEL;
+var HILL_TOP, STILL_DAYS$1, HILL_PHASE_LABEL;
 var init_hill = __esmMin((() => {
 	init_date_fns();
 	HILL_TOP = 50;
-	STILL_DAYS = 14;
+	STILL_DAYS$1 = 14;
 	HILL_PHASE_LABEL = {
 		figuring: "Figuring it out",
 		doing: "Getting it done"
@@ -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);
@@ -14807,6 +14970,12 @@ function taskMinutes(task) {
 function entriesNewestFirst(task) {
 	return [...task.time ?? []].sort((a, b) => (b.on + b.at).localeCompare(a.on + a.at));
 }
+/** The ISO day `n` days before `iso`. */
+function daysBefore(iso, n) {
+	const d = /* @__PURE__ */ new Date(`${iso}T12:00:00Z`);
+	d.setUTCDate(d.getUTCDate() - n);
+	return d.toISOString().slice(0, 10);
+}
 
 // src/lib/goals.ts
 init_indexes();
@@ -20783,8 +20952,8 @@ init_date_fns();
 init_blockers();
 init_format();
 init_indexes();
-const noon = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
-const days$2 = (from, to) => differenceInCalendarDays(noon(to), noon(from));
+const noon$1 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+const days$2 = (from, to) => differenceInCalendarDays(noon$1(to), noon$1(from));
 const later = (a, b) => !a ? b : !b ? a : a >= b ? a : b;
 const open = (t) => t.status !== "done";
 /** True when `a` finishes later than `b`, or as late behind a longer line. */
@@ -21815,8 +21984,349 @@ var init_fog = __esmMin((() => {
 	fileCache = /* @__PURE__ */ new WeakMap();
 }));
 
-// src/lib/task-approval.ts
+// src/lib/assignment.ts
+/**
+* Record who set a task's assignee and when. Only a change of assignee
+* stamps; clearing the assignee clears the stamp.
+*/
+function stampAssignment(before, next, by, at) {
+	if (before && before.assigneeId === next.assigneeId) return next;
+	if (!next.assigneeId) return {
+		...next,
+		assignedBy: null,
+		assignedAt: null
+	};
+	return {
+		...next,
+		assignedBy: by,
+		assignedAt: at
+	};
+}
+var init_assignment = __esmMin((() => {}));
+
+// src/lib/scuttle-rows.ts
+/** Whether it's scuttled: closed through Scuttle or sail and not raised since. */
+function isScuttled(project) {
+	return Boolean(project.scuttled) && project.healthOverride === "done";
+}
+/**
+* Scuttle a project: Done by hand with the reason as its note, its open
+* tasks unassigned and undated (kept in `scuttled.freed`), and a decision on
+* the register. Null for a project that's already scuttled or gone, or a
+* blank why.
+*/
+function scuttleRows(data, projectId, why, byId, at, decisionId, context = "Closed through Scuttle or sail.") {
+	const project = data.projects.find((p) => p.id === projectId);
+	const reason = why.trim().slice(0, 600);
+	if (!project || !reason || isScuttled(project)) return null;
+	const freed = [];
+	const tasks = [];
+	for (const t of tasksOf(data.tasks, projectId)) {
+		if (t.status === "done" || !t.assigneeId && !t.dueDate) continue;
+		freed.push({
+			taskId: t.id,
+			assigneeId: t.assigneeId,
+			dueDate: t.dueDate
+		});
+		tasks.push(stampAssignment(t, {
+			...t,
+			assigneeId: null,
+			dueDate: null,
+			touchedAt: at
+		}, byId, at));
+	}
+	const decision = normalizeRaidItem({
+		id: decisionId,
+		kind: "decision",
+		projectId,
+		title: `Scuttle ${project.name}`,
+		description: context,
+		status: "decided",
+		severity: "low",
+		ownerId: byId,
+		dueDate: null,
+		resolution: "Stop the project. Its open tasks come off people’s lists.",
+		rationale: reason,
+		decidedById: byId,
+		decidedAt: at,
+		createdById: byId,
+		createdAt: at,
+		updatedAt: at,
+		updates: []
+	});
+	return {
+		project: {
+			...project,
+			health: "done",
+			healthOverride: "done",
+			healthNote: `Scuttled: ${reason}`,
+			scuttled: {
+				at,
+				byId,
+				why: reason,
+				decisionId,
+				freed
+			}
+		},
+		tasks,
+		decision
+	};
+}
+/**
+* Raise a scuttled project: the scuttle cleared (the caller clears its Done), and each
+* freed task given back its person and date, unless someone has since given
+* it others, it's done, or the person has left the crew. Null when it isn't
+* scuttled.
+*/
+function raiseRows(data, projectId, at, byId) {
+	const project = data.projects.find((p) => p.id === projectId);
+	if (!project?.scuttled) return null;
+	const people = new Set(data.people.map((p) => p.id));
+	const byTask = new Map(project.scuttled.freed.map((f) => [f.taskId, f]));
+	const tasks = [];
+	for (const t of tasksOf(data.tasks, projectId)) {
+		const f = byTask.get(t.id);
+		if (!f || t.status === "done") continue;
+		const assigneeId = !t.assigneeId && f.assigneeId && people.has(f.assigneeId) ? f.assigneeId : t.assigneeId;
+		const dueDate = t.dueDate ?? f.dueDate;
+		if (assigneeId === t.assigneeId && dueDate === t.dueDate) continue;
+		tasks.push(stampAssignment(t, {
+			...t,
+			assigneeId,
+			dueDate,
+			touchedAt: at
+		}, byId, at));
+	}
+	return {
+		project: {
+			...project,
+			scuttled: null,
+			voyageCall: {
+				call: "sail",
+				at,
+				byId
+			}
+		},
+		tasks
+	};
+}
+var WHY_MAX;
+var init_scuttle_rows = __esmMin((() => {
+	init_assignment();
+	init_indexes();
+	init_raid();
+	WHY_MAX = 600;
+}));
+
+// src/lib/scuttle.ts
+init_date_fns();
 init_fog();
+init_indexes();
+init_scuttle_rows();
+init_spend();
+init_format();
+/** Days with nothing moving before a project reads as still. */
+const STILL_DAYS = 28;
+/** A project younger than this is left alone: it's still being set up. */
+const YOUNG_DAYS = 21;
+/** Sailing on or a refit keeps it out of the line-up this long. */
+const QUIET_DAYS = 90;
+/** Slips are counted over this window. */
+const SLIP_WINDOW_DAYS = 90;
+/** This many falls into trouble in the window reads as slipping again and again. */
+const SLIP_TIMES = 3;
+/** Its end date this far past the baseline reads as drifting. */
+const DRIFT_DAYS = 21;
+/** This far past its end date with work open. */
+const OVERDUE_DAYS = 14;
+/** Paused this long. */
+const PAUSED_DAYS = 30;
+const noon = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+const daysSince = (iso, today) => differenceInCalendarDays(noon(today), noon(iso));
+const TRACK = {
+	"on-track": 0,
+	"at-risk": 1,
+	"off-track": 2
+};
+/** When anything last moved on the project: its tasks (as fog reads them) and its hill dot. */
+function lastMoved(project, data) {
+	let last = project.hillMovedAt ?? null;
+	for (const t of tasksOf(data.tasks, project.id)) {
+		const at = lastTouch(t, data);
+		if (!last || at > last) last = at;
+	}
+	return last;
+}
+/** Times its health fell (on track to at risk or off track, at risk to off track) since `since`. */
+function slipsSince(project, since) {
+	let times = 0;
+	let prev;
+	for (const line of project.healthHistory ?? []) {
+		const rank = TRACK[line.health];
+		if (rank === void 0) {
+			prev = void 0;
+			continue;
+		}
+		if (prev !== void 0 && rank > prev && line.at.slice(0, 10) >= since) times += 1;
+		prev = rank;
+	}
+	return times;
+}
+/** Days it has been paused, from the history's latest line saying so; null when it isn't, or nobody knows since when. */
+function pausedDays(project, today) {
+	if (project.health !== "paused") return null;
+	const history = project.healthHistory ?? [];
+	let since = null;
+	for (let i = history.length - 1; i >= 0; i--) {
+		if (history[i].health !== "paused") break;
+		since = history[i].at;
+	}
+	return since ? Math.max(0, daysSince(since, today)) : null;
+}
+/** A goal's work key result names it or its program. Only asked when its portfolio has goals at all. */
+function aimless(project, data) {
+	const program = data.programs.find((p) => p.id === project.programId);
+	const goals = (program && data.portfolios.find((p) => p.id === program.portfolioId))?.goals ?? [];
+	if (goals.length === 0) return false;
+	return !goals.some((g) => g.keyResults.some((kr) => kr.kind === "work" && (kr.linkIds ?? []).some((id) => id === project.id || id === project.programId)));
+}
+const STRENGTH = {
+	overdue: 0,
+	still: 1,
+	empty: 1,
+	paused: 2,
+	slipping: 3,
+	drifted: 4,
+	aimless: 5
+};
+/** The signs that put a project in the line-up today, strongest first; empty when it's sailing fine. */
+function zombieSigns(project, data, today) {
+	const signs = [];
+	const tasks = tasksOf(data.tasks, project.id);
+	const open = tasks.filter((t) => t.status !== "done").length;
+	const age = daysSince(project.startDate, today);
+	if (tasks.length === 0) {
+		if (age >= 28) signs.push({
+			kind: "empty",
+			days: age
+		});
+	} else if (project.health !== "paused") {
+		const moved = lastMoved(project, data);
+		const still = moved ? daysSince(moved, today) : age;
+		if (still >= 28) signs.push({
+			kind: "still",
+			days: still
+		});
+	}
+	const paused = pausedDays(project, today);
+	if (paused !== null && paused >= 30) signs.push({
+		kind: "paused",
+		days: paused
+	});
+	const late = daysSince(project.endDate, today);
+	if (open > 0 && late >= 14 && project.health !== "paused") signs.push({
+		kind: "overdue",
+		days: late,
+		open
+	});
+	const slips = slipsSince(project, daysBefore(today, 90));
+	if (slips >= 3) signs.push({
+		kind: "slipping",
+		times: slips
+	});
+	if (project.baselineEnd) {
+		const drift = differenceInCalendarDays(noon(project.endDate), noon(project.baselineEnd));
+		if (drift >= 21) signs.push({
+			kind: "drifted",
+			days: drift
+		});
+	}
+	if (signs.length > 0 && aimless(project, data)) signs.push({ kind: "aimless" });
+	return signs.sort((a, b) => STRENGTH[a.kind] - STRENGTH[b.kind]);
+}
+/** Left out of the line-up: finished, scuttled, too young, or answered within the quarter. */
+function restingFromReview(project, today) {
+	if (project.health === "done" || isScuttled(project)) return true;
+	if (project.startDate > today || daysSince(project.startDate, today) < 21) return true;
+	const call = project.voyageCall;
+	return Boolean(call && daysSince(call.at, today) < 90);
+}
+/** What scuttling it would free: open tasks by person, logged hours and spend a week. */
+function whatItHolds(project, data, now) {
+	const today = todayISO(now);
+	const tasks = tasksOf(data.tasks, project.id);
+	const by = /* @__PURE__ */ new Map();
+	let openTasks = 0;
+	let minutes = 0;
+	const from = daysBefore(today, 27);
+	for (const t of tasks) {
+		for (const e of t.time ?? []) if (e.on >= from && e.on <= today) minutes += e.minutes;
+		if (t.status === "done") continue;
+		openTasks += 1;
+		if (t.assigneeId) by.set(t.assigneeId, (by.get(t.assigneeId) ?? 0) + 1);
+	}
+	const crew = [...by].map(([personId, open]) => ({
+		personId,
+		open
+	})).sort((a, b) => b.open - a.open);
+	const burn = project.budget > 0 ? burnPerDay(spendEntriesOf({ spendEntries: data.spendEntries ?? [] }, project.id), project.startDate, now) : null;
+	return {
+		openTasks,
+		crew,
+		hoursPerWeek: minutes > 0 ? Math.round(minutes / 60 / 4 * 10) / 10 : null,
+		spendPerWeek: burn ? Math.round(burn * 7) : null
+	};
+}
+/**
+* The line-up: projects showing a zombie sign that aren't resting, the ones
+* with the most signs first, then the stillest. `projectIds` narrows it to a
+* portfolio's or program's; leave it out for the whole harbor.
+*/
+function scuttleLineUp(data, now, projectIds) {
+	const today = todayISO(now);
+	const out = [];
+	for (const project of data.projects) {
+		if (projectIds && !projectIds.has(project.id)) continue;
+		if (restingFromReview(project, today)) continue;
+		const signs = zombieSigns(project, data, today);
+		if (signs.length === 0) continue;
+		out.push({
+			project,
+			signs,
+			lastMoved: lastMoved(project, data),
+			...whatItHolds(project, data, now)
+		});
+	}
+	const still = (z) => {
+		const s = z.signs.find((x) => x.kind === "still" || x.kind === "empty");
+		return s && "days" in s ? s.days : 0;
+	};
+	return out.sort((a, b) => b.signs.length - a.signs.length || still(b) - still(a) || a.project.name.localeCompare(b.project.name));
+}
+/** The projects in a portfolio or a program, for narrowing the line-up. */
+function projectIdsUnder(data, scope) {
+	const programs = new Set(scope.programId ? [scope.programId] : data.programs.filter((p) => p.portfolioId === scope.portfolioId).map((p) => p.id));
+	return new Set(data.projects.filter((p) => programs.has(p.programId)).map((p) => p.id));
+}
+/** "6 weeks", "10 days". */
+function spanText(days) {
+	if (days >= 14) return `${Math.floor(days / 7)} weeks`;
+	return `${days} day${days === 1 ? "" : "s"}`;
+}
+/** One sign in a short sentence. */
+function signText(sign) {
+	switch (sign.kind) {
+		case "still": return `Nothing has moved in ${spanText(sign.days)}`;
+		case "empty": return `No tasks, ${spanText(sign.days)} after it started`;
+		case "slipping": return `Slipped into trouble ${sign.times} times in three months`;
+		case "drifted": return `Its end date has moved ${spanText(sign.days)} past the plan`;
+		case "overdue": return `${spanText(sign.days)} past its end date, ${sign.open} task${sign.open === 1 ? "" : "s"} still open`;
+		case "paused": return `Paused for ${spanText(sign.days)}`;
+		case "aimless": return "No goal behind it";
+	}
+}
+
+// src/lib/task-approval.ts
 /** Waits on its approver now: asked, not yet answered, and not done. */
 function awaitingApproval(task) {
 	return Boolean(task?.approval && task.approval.status === "pending" && task.status !== "done");
@@ -21853,6 +22363,7 @@ init_handover();
 init_agents();
 init_work();
 init_task_people();
+init_fog();
 init_passage();
 init_board();
 init_holidays();
@@ -22480,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.")
@@ -22544,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 })
@@ -23693,6 +24205,53 @@ const HARBOR_TOOLS = [
 			};
 		}
 	}),
+	tool({
+		name: "scuttle_or_sail",
+		title: "Projects that look adrift",
+		description: "Scuttle or sail: running projects that look like zombies (nothing moved for four weeks, no tasks a month in, two weeks past the end with work open, paused for a month, slipped into trouble three times in three months, or the end date moved three weeks past the baseline; \"no goal behind it\" is added when the portfolio keeps goals), the most signs first. Each says what stopping it would free: open tasks by person, logged hours a week, spend a week. Projects someone kept or refitted in the last three months, finished ones and ones under three weeks old are left out. Walk the person through them one at a time; answer_scuttle_or_sail records sail on, refit or scuttle, only on their word." + DATA_NOTE,
+		input: object({
+			harbor: harborArg,
+			portfolio: string().max(200).optional().describe("Portfolio id or name, for its projects only."),
+			program: string().max(200).optional().describe("Program id or name, for its projects only."),
+			limit: limitArg(100, 25),
+			offset: offsetArg
+		}),
+		run: (ctx, input) => {
+			const { data } = ctx;
+			const program = input.program ? findOne(data.programs, input.program, "program") : null;
+			const portfolio = !program && input.portfolio ? findOne(data.portfolios, input.portfolio, "portfolio") : null;
+			const ids = program || portfolio ? projectIdsUnder(data, {
+				programId: program?.id,
+				portfolioId: portfolio?.id
+			}) : void 0;
+			const lineUp = scuttleLineUp(data, ctx.now, ids);
+			const people = byId(data.people);
+			return {
+				...program ? { program: program.name } : portfolio ? { portfolio: portfolio.name } : {},
+				adrift: lineUp.length,
+				projects: lineUp.slice(input.offset, input.offset + input.limit).map((z) => ({
+					project: z.project.name,
+					...z.project.key ? { key: z.project.key } : {},
+					health: z.project.health,
+					endDate: z.project.endDate,
+					owner: people.get(z.project.ownerId)?.name ?? null,
+					signs: z.signs.map((s) => ({
+						kind: s.kind,
+						text: signText(s)
+					})),
+					lastMoved: dayOf(z.lastMoved),
+					openTasks: z.openTasks,
+					crew: z.crew.map((c) => ({
+						person: people.get(c.personId)?.name ?? null,
+						openTasks: c.open
+					})),
+					hoursPerWeek: z.hoursPerWeek,
+					spendPerWeek: z.spendPerWeek
+				})),
+				more: lineUp.length > input.offset + input.limit
+			};
+		}
+	}),
 	tool({
 		name: "lifeboats",
 		title: "Work only one person knows",
@@ -24487,26 +25046,6 @@ var init_session = __esmMin((() => {
 	init_format();
 }));
 
-// src/lib/assignment.ts
-/**
-* Record who set a task's assignee and when. Only a change of assignee
-* stamps; clearing the assignee clears the stamp.
-*/
-function stampAssignment(before, next, by, at) {
-	if (before && before.assigneeId === next.assigneeId) return next;
-	if (!next.assigneeId) return {
-		...next,
-		assignedBy: null,
-		assignedAt: null
-	};
-	return {
-		...next,
-		assignedBy: by,
-		assignedAt: at
-	};
-}
-var init_assignment = __esmMin((() => {}));
-
 // src/lib/first-week.ts
 /** The program launch named for you, when nobody has renamed it yet. */
 function starterProgram(data) {
@@ -24518,6 +25057,33 @@ var init_first_week = __esmMin((() => {
 
 // src/lib/slices/hierarchy.ts
 function hierarchySlice({ get, write }) {
+	/**
+	* A scuttled project being reopened (its Done cleared or changed): its
+	* freed tasks get their people and dates back, and its decision says so.
+	* Null when it isn't scuttled.
+	*/
+	const raise = (projectId, at) => {
+		const s = get();
+		const rows = raiseRows(s, projectId, at, s.currentUserId);
+		if (!rows) return null;
+		const changed = new Map(rows.tasks.map((t) => [t.id, t]));
+		const decisionId = s.projects.find((p) => p.id === projectId)?.scuttled?.decisionId;
+		const note = {
+			id: uid("ru"),
+			authorId: s.currentUserId,
+			body: "Raised again: the project is back, and its tasks went back to their people.",
+			createdAt: at
+		};
+		return {
+			projects: s.projects.map((p) => p.id === projectId ? rows.project : p),
+			tasks: s.tasks.map((t) => changed.get(t.id) ?? t),
+			raidItems: s.raidItems.map((r) => r.id === decisionId ? {
+				...r,
+				updates: [...r.updates, note],
+				updatedAt: at
+			} : r)
+		};
+	};
 	return {
 		addPortfolio: (p) => {
 			const id = uid("pf");
@@ -24666,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 ? {
@@ -24762,11 +25342,24 @@ function hierarchySlice({ get, write }) {
 					programs: get().programs.map((p) => p.id === id ? mark(p) : p),
 					projects: parked ? get().projects.map((p) => p.programId === id && (!p.healthOverride || p.healthOverride === "paused" || p.healthOverride === "done") ? mark(p) : p) : get().projects
 				});
-			} else write({ projects: get().projects.map((p) => p.id === id ? mark(p) : p) });
+			} else {
+				const raised = health === "done" ? null : raise(id, at);
+				write({
+					projects: (raised?.projects ?? get().projects).map((p) => p.id === id ? mark(p) : p),
+					...raised ? {
+						tasks: raised.tasks,
+						raidItems: raised.raidItems
+					} : {}
+				});
+			}
 		},
 		clearHealthOverride: (kind, id) => {
 			const at = stamp();
-			const s = get();
+			const raised = kind === "project" ? raise(id, at) : null;
+			const s = raised ? {
+				...get(),
+				...raised
+			} : get();
 			const cleared = {
 				portfolio: /* @__PURE__ */ new Set(),
 				program: /* @__PURE__ */ new Set(),
@@ -24801,9 +25394,59 @@ function hierarchySlice({ get, write }) {
 			write({
 				portfolios: next.portfolios.map(byRules("portfolio")),
 				programs: next.programs.map(byRules("program")),
-				projects: next.projects.map(byRules("project"))
+				projects: next.projects.map(byRules("project")),
+				...raised ? {
+					tasks: raised.tasks,
+					raidItems: raised.raidItems
+				} : {}
 			});
 		},
+		scuttleProject: (projectId, why, context) => {
+			const s = get();
+			const at = stamp();
+			const decisionId = uid("raid");
+			const rows = scuttleRows(s, projectId, why, s.currentUserId, at, decisionId, context);
+			if (!rows) return null;
+			const before = s.projects.find((p) => p.id === projectId);
+			const changed = new Map(rows.tasks.map((t) => [t.id, t]));
+			write({
+				projects: s.projects.map((p) => p.id === projectId ? {
+					...rows.project,
+					healthHistory: recordHealth(p.healthHistory, "done", at, true, rows.project.healthNote)
+				} : p),
+				tasks: s.tasks.map((t) => changed.get(t.id) ?? t),
+				raidItems: [...s.raidItems, rows.decision]
+			});
+			get().log(`scuttled ${before.name}`, `/projects/${projectId}`);
+			return {
+				project: before,
+				tasks: s.tasks.filter((t) => changed.has(t.id)),
+				decisionId
+			};
+		},
+		undoScuttle: (undo) => {
+			const s = get();
+			const back = new Map(undo.tasks.map((t) => [t.id, t]));
+			write({
+				projects: s.projects.map((p) => p.id === undo.project.id ? undo.project : p),
+				tasks: s.tasks.map((t) => back.get(t.id) ?? t),
+				raidItems: s.raidItems.filter((r) => r.id !== undo.decisionId)
+			});
+		},
+		answerVoyage: (projectId, call, note) => {
+			const at = stamp();
+			const byId = get().currentUserId;
+			const text = note?.trim().slice(0, 300);
+			write({ projects: get().projects.map((p) => p.id === projectId ? {
+				...p,
+				voyageCall: {
+					call,
+					at,
+					byId,
+					...text ? { note: text } : {}
+				}
+			} : p) });
+		},
 		snapshotBaseline: (programId, reset = false) => {
 			const inProgram = new Set(get().projects.filter((p) => p.programId === programId).map((p) => p.id));
 			const stamped = withBaseline(get().projects.filter((p) => inProgram.has(p.id)), reset, stamp());
@@ -24961,8 +25604,10 @@ var init_hierarchy = __esmMin((() => {
 	init_derived_health();
 	init_shared();
 	init_assignment();
+	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,
@@ -54,6 +55,8 @@ import {
   catchupText,
   handoverText,
   fogText,
+  scuttleText,
+  scuttleCallText,
   agentWorkText,
   raidDetail,
   raidList,
@@ -261,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
@@ -295,6 +303,13 @@ export const HELP = `harbor: Harbor from the terminal
   harbor fog --sweep [--project P]            one at a time: still needed, a
                                               new date, or drop it
   harbor fog keep TASK                        it's still needed: out of the fog
+  harbor scuttle [--program P|--portfolio P]  projects that look adrift: still
+                                              for weeks, slipping, long late
+  harbor scuttle sail|refit PROJECT [--end DATE] [--note TEXT]
+                                              keep it, or refit it, for three
+                                              months out of the line-up
+  harbor scuttle PROJECT --why "TEXT"         stop it on purpose: Done, on the
+                                              register, its tasks set free
   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
@@ -1016,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",
@@ -1149,6 +1182,24 @@ const DETAIL = {
     "  The sweep needs a terminal and full access (harbor login without",
     "  --read-only), since dropping a task deletes it.",
   ],
+  scuttle: [
+    "  harbor scuttle [--program P]           reads: running projects that look",
+    "                 [--portfolio P]         adrift (nothing moved for four",
+    "                                         weeks, slipping again and again, long",
+    "                                         past the end, paused for a month),",
+    "                                         and what stopping each would free",
+    "  harbor scuttle sail PROJECT            writes: keep it sailing; it leaves",
+    "                                         the line-up for three months",
+    "  harbor scuttle refit PROJECT           writes: a new end date and/or a line",
+    '                 [--end DATE] [--note "TEXT"]  on what changes',
+    '  harbor scuttle PROJECT --why "TEXT"    writes: stop it. It closes as Done',
+    "                                         with the why as its note, a decision",
+    "                                         goes on the register, and its open",
+    "                                         tasks come off people's lists",
+    "",
+    "  Nothing is deleted: harbor health auto --project P raises a scuttled project",
+    "  again and gives its tasks back.",
+  ],
   watch: [
     "  harbor watch                           reads, live: each change to the harbor",
     "                                         as it lands, one line with its time",
@@ -3259,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;
@@ -3579,6 +3694,49 @@ export async function run(argv, io = {}) {
       }
       return call("fog", { harbor, project: values.project, limit: 100 }, (r) => fogText(r));
     }
+    case "scuttle": {
+      const { positionals, values, harbor } = parse(
+        spec(["list"], ["program", "portfolio", "end", "note", "why"]),
+      );
+      const [first, ...rest] = positionals;
+      if (first === "sail" || first === "refit") {
+        if (values.why !== undefined)
+          throw new HarborError(`--why goes with scuttling: harbor scuttle PROJECT --why "TEXT".`);
+        const project = one(rest, "project");
+        if (first === "sail" && (values.end !== undefined || values.note !== undefined))
+          throw new HarborError("--end and --note go with a refit: harbor scuttle refit PROJECT --end DATE.");
+        if (first === "refit" && values.end === undefined && values.note === undefined)
+          throw new HarborError('A refit needs --end DATE or --note "what changes".');
+        return call(
+          "answer_scuttle_or_sail",
+          {
+            harbor,
+            project,
+            call: first,
+            ...(values.end !== undefined ? { endDate: dueDate(values.end) } : {}),
+            ...(values.note !== undefined ? { note: values.note } : {}),
+          },
+          scuttleCallText,
+        );
+      }
+      if (first !== undefined) {
+        const project = one(positionals, "project");
+        if (values.why === undefined || !values.why.trim())
+          throw new HarborError(
+            `Say why it stops: harbor scuttle ${project} --why "TEXT". To keep it: harbor scuttle sail ${project}.`,
+          );
+        return call(
+          "answer_scuttle_or_sail",
+          { harbor, project, call: "scuttle", why: values.why },
+          scuttleCallText,
+        );
+      }
+      return call(
+        "scuttle_or_sail",
+        { harbor, program: values.program, portfolio: values.portfolio, limit: 100 },
+        scuttleText,
+      );
+    }
     case "bridge": {
       const { positionals, values, harbor } = parse(spec(["list"], ["program"]));
       none(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`;
@@ -1124,6 +1152,45 @@ export function fogText(r, { sweepHint = true } = {}) {
   return lines.join("\n");
 }
 
+/** harbor scuttle: projects that look adrift, with what stopping each would free. */
+export function scuttleText(r) {
+  const where = r.program ? ` in ${r.program}` : r.portfolio ? ` in ${r.portfolio}` : "";
+  if (!r.adrift)
+    return `Nothing looks adrift${where}: every running project has moved lately, and none keeps slipping.`;
+  const lines = [
+    `${r.adrift} ${r.adrift === 1 ? "project looks" : "projects look"} adrift${where}. Keep each sailing, refit it, or stop it on purpose.`,
+    "",
+  ];
+  for (const p of r.projects) {
+    lines.push(
+      `  ${(p.key ?? "").padEnd(5)} ${p.project}${p.owner ? ` · ${p.owner}` : ""} · ends ${p.endDate}`,
+    );
+    for (const s of p.signs) lines.push(`        ${s.text}`);
+    const frees = [
+      `${p.openTasks} open task${p.openTasks === 1 ? "" : "s"}`,
+      p.crew.length ? `with ${p.crew.map((c) => c.person).filter(Boolean).join(", ")}` : null,
+      p.hoursPerWeek ? `${p.hoursPerWeek}h a week logged` : null,
+      p.spendPerWeek ? `$${p.spendPerWeek.toLocaleString("en-US")} a week of spend` : null,
+    ];
+    lines.push(`        holds ${frees.filter(Boolean).join(" · ")}`);
+  }
+  if (r.more) lines.push("", `And ${r.adrift - r.projects.length} more.`);
+  lines.push(
+    "",
+    'harbor scuttle sail PROJECT keeps one, harbor scuttle refit PROJECT --end DATE refits it, harbor scuttle PROJECT --why "TEXT" stops it.',
+  );
+  return lines.join("\n");
+}
+
+/** What harbor scuttle sail, refit or PROJECT --why did. */
+export function scuttleCallText(r) {
+  if (r.call === "scuttle")
+    return `Scuttled ${r.project}. ${r.sendOff} The why is on the register as a decision; harbor health auto --project "${r.project}" raises it again.`;
+  if (r.call === "refit")
+    return `Refitted ${r.project}: ${r.note ?? `ends ${r.endDate}`}. It's out of the line-up until ${r.quietUntil}.`;
+  return `${r.project} sails on. It's out of the line-up until ${r.quietUntil}.`;
+}
+
 /** harbor lifeboats: work only one person knows, numbered for harbor lifeboats N. */
 export function lifeboatsText(r) {
   const where = r.program ? ` in ${r.program}` : "";

package/package.json

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