@harborppm/cli 0.58.0 → 0.59.0

package/README.md

@@ -190,8 +190,9 @@ harbor import FILE [--project P] [--portfolio P] [--no-people]
 harbor premortem PROJECT ["WHAT WENT WRONG"] [--start]
 harbor voyage PROJECT ["YOUR LINE"]
 harbor note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]
-harbor sound TASK [DAYS] [--why TEXT] [--ask NAMES|crew] [--settle DAYS]
+harbor sound TASK [--answer DAYS|--ask NAMES|--settle DAYS] [--why TEXT]
 harbor soundings [PROJECT]
+harbor ashore [--weeks N] [--country CODES|none] [--person NAME]
 harbor limit PROJECT [COLUMN N|none]
 harbor week [--next|--last|--week DATE] [--review]
 harbor week TASK DAY [--hours N] | week TASK --off [DAY] | week --day-hours N
@@ -227,7 +228,7 @@ Agents on the crew: put an AI app on People with Add an agent and assign it task
 
 `harbor limit RR` prints how many tasks each of a board's columns takes at once; `harbor limit RR doing 8` changes one (1 to 20, or `none` for no limit), if you own the harbor. `harbor projects --json` carries each board's `limits` too.
 
-`harbor premortem` runs a pre-mortem with your crew: `--start` asks everyone "it's after the end date and this project failed: what happened?", each person adds answers alone for five minutes, and then the answers show together on the project's Risks & issues tab, where each becomes a risk in one click. On its own it prints the question and the answers you can see. Once a project is Done, `harbor voyage` prints its voyage log (planned against actual dates, the biggest slips, the risks that came true, who closed the most, and the crew's lines) and adds yours. `harbor note` leaves a note for later on a project: it stays sealed (the crew sees only that it's there and who left it) until its day, until one of the program's milestones is reached, or until the project turns Off track, and then it opens at the top of the project and in the brief. `harbor sound TASK --ask crew` takes a sounding: it asks you, the task's owner and whoever has open work on its project how many working days the task will take (`--ask "Sam,Priya"` picks who). Each person answers alone with `harbor sound TASK 4 --why "…"`, and nobody sees the others' numbers until everyone has; then `harbor sound TASK` shows the spread, an estimate when the guesses are close, or "talk about this first" when they're far apart, and `--settle DAYS` records what you agreed. `harbor soundings` lists them, the ones waiting on your answer first.
+`harbor premortem` runs a pre-mortem with your crew: `--start` asks everyone "it's after the end date and this project failed: what happened?", each person adds answers alone for five minutes, and then the answers show together on the project's Risks & issues tab, where each becomes a risk in one click. On its own it prints the question and the answers you can see. Once a project is Done, `harbor voyage` prints its voyage log (planned against actual dates, the biggest slips, the risks that came true, who closed the most, and the crew's lines) and adds yours. `harbor note` leaves a note for later on a project: it stays sealed (the crew sees only that it's there and who left it) until its day, until one of the program's milestones is reached, or until the project turns Off track, and then it opens at the top of the project and in the brief. `harbor sound TASK --ask crew` takes a sounding: it asks you, the task's owner and whoever has open work on its project how many working days the task will take (`--ask "Sam,Priya"` picks who). Each person answers alone with `harbor sound TASK --answer 4 --why "…"`, and nobody sees the others' numbers until everyone has; then `harbor sound TASK` shows the spread, an estimate when the guesses are close, or "talk about this first" when they're far apart, and `--settle DAYS` records what you agreed. `harbor soundings` lists them, the ones waiting on your answer first. `harbor ashore` lists the public holidays and time away in the next eight weeks; `--country US,GB` sets whose holidays the harbor takes and `--person NAME --country DE` one person's own, which the forecast and the weekly load then count as days off.
 
 `harbor brief --say` turns the brief into the BBC's Shipping Forecast: each program an area, wind for late work, visibility for health, gale warnings for anything off track. It prints the forecast and speaks it with your computer's own voice (`say` on a Mac, Windows' speech, or `espeak-ng` on Linux, which you may need to install). With `--json` it prints the forecast and stays quiet.
 

package/dist/app.mjs

@@ -2974,7 +2974,7 @@ const scale = (labels) => [
 	label: `${n} ${labels[n]}`,
 	value: n
 }));
-const plus = (today, days) => format(addDays(parseIso(today), days), "yyyy-MM-dd");
+const plus$1 = (today, days) => format(addDays(parseIso(today), days), "yyyy-MM-dd");
 /** The colour a new project or program takes: the first one its neighbours don't use. */
 function nextSwatch(used) {
 	return SWATCHES.find((s) => !used.includes(s)) ?? SWATCHES[0];
@@ -3236,7 +3236,7 @@ function commitCreate(store, kind, v, ctx, today) {
 				ownerId: str("ownerId"),
 				programId,
 				startDate: today,
-				endDate: str("endDate") ? clampEndToParent(str("endDate"), program.endDate, today) : reckoning ? reckonedEnd(reckoning, today) : clampEndToParent(plus(today, 60), program.endDate, today),
+				endDate: str("endDate") ? clampEndToParent(str("endDate"), program.endDate, today) : reckoning ? reckonedEnd(reckoning, today) : clampEndToParent(plus$1(today, 60), program.endDate, today),
 				budget: typeof v.budget === "number" ? v.budget : 0
 			});
 			if (reckoning) applyReckoning(store.getState(), id, reckoning, today);
@@ -3252,7 +3252,7 @@ function commitCreate(store, kind, v, ctx, today) {
 				ownerId: str("ownerId"),
 				portfolioId,
 				startDate: today,
-				endDate: str("endDate") || plus(today, 90)
+				endDate: str("endDate") || plus$1(today, 90)
 			});
 		}
 		case "milestone":
@@ -3260,7 +3260,7 @@ function commitCreate(store, kind, v, ctx, today) {
 			return s.addMilestone({
 				programId: ctx.programId,
 				name: str("name"),
-				dueDate: str("dueDate") || plus(today, 14)
+				dueDate: str("dueDate") || plus$1(today, 14)
 			});
 		case "raid": {
 			const projectId = ctx.projectId ?? (v.projectId || null);
@@ -3707,14 +3707,19 @@ function soundingDraws(task, reflections) {
 	if (s.settledDays != null) return [s.settledDays];
 	return answersFor(reflections, task).map((a) => a.days);
 }
-/** Calendar days from `from` until `days` working days (Monday to Friday) have passed. */
-function workingDaysAhead(days, from) {
+/**
+* Calendar days from `from` until `days` working days have passed: Monday
+* to Friday, or the days `works` says (a person's holidays and time away,
+* src/lib/holidays.ts). Gives up after two years.
+*/
+function workingDaysAhead(days, from, works) {
 	let left = Math.ceil(days);
 	let d = 0;
-	while (left > 0) {
+	while (left > 0 && d < 730) {
 		d += 1;
-		const wd = addDays(from, d).getDay();
-		if (wd !== 0 && wd !== 6) left -= 1;
+		const at = addDays(from, d);
+		const wd = at.getDay();
+		if (works ? works(at) : wd !== 0 && wd !== 6) left -= 1;
 	}
 	return d;
 }
@@ -3758,11 +3763,508 @@ var init_soundings = __esmMin((() => {
 	SOUNDING_MAX_DAYS = 250;
 }));
 
+//#endregion
+//#region src/lib/countries.ts
+/** A country code Harbor has holidays for, upper-cased; null otherwise. */
+function countryCode(text) {
+	if (!text) return null;
+	const t = text.trim();
+	const up = t.toUpperCase();
+	if (KNOWN.has(up)) return up;
+	if (up === "UK") return "GB";
+	if (up === "USA") return "US";
+	return COUNTRIES.find((c) => c.name.toLowerCase() === t.toLowerCase())?.code ?? null;
+}
+var COUNTRIES, KNOWN, countryName;
+var init_countries = __esmMin((() => {
+	COUNTRIES = [
+		{
+			code: "AU",
+			name: "Australia"
+		},
+		{
+			code: "BR",
+			name: "Brazil"
+		},
+		{
+			code: "CA",
+			name: "Canada"
+		},
+		{
+			code: "FR",
+			name: "France"
+		},
+		{
+			code: "DE",
+			name: "Germany"
+		},
+		{
+			code: "IE",
+			name: "Ireland"
+		},
+		{
+			code: "IT",
+			name: "Italy"
+		},
+		{
+			code: "MX",
+			name: "Mexico"
+		},
+		{
+			code: "NL",
+			name: "Netherlands"
+		},
+		{
+			code: "NZ",
+			name: "New Zealand"
+		},
+		{
+			code: "ES",
+			name: "Spain"
+		},
+		{
+			code: "GB",
+			name: "United Kingdom"
+		},
+		{
+			code: "US",
+			name: "United States"
+		}
+	];
+	KNOWN = new Set(COUNTRIES.map((c) => c.code));
+	countryName = (code) => COUNTRIES.find((c) => c.code === code)?.name ?? code;
+}));
+
+//#endregion
+//#region src/lib/holidays.ts
+init_soundings();
+init_date_fns();
+init_format();
+init_countries();
+const iso$4 = (y, m, d) => todayISO(new Date(y, m - 1, d, 12));
+const weekday = (day) => (/* @__PURE__ */ new Date(`${day}T12:00:00`)).getDay();
+const plus = (day, n) => todayISO(addDays(/* @__PURE__ */ new Date(`${day}T12:00:00`), n));
+const isWeekend = (day) => {
+	const wd = weekday(day);
+	return wd === 0 || wd === 6;
+};
+/** Easter Sunday (the anonymous Gregorian algorithm). */
+function easter(year) {
+	const a = year % 19;
+	const b = Math.floor(year / 100);
+	const c = year % 100;
+	const d = Math.floor(b / 4);
+	const e = b % 4;
+	const f = Math.floor((b + 8) / 25);
+	const g = Math.floor((b - f + 1) / 3);
+	const h = (19 * a + b - d - g + 15) % 30;
+	const i = Math.floor(c / 4);
+	const k = c % 4;
+	const l = (32 + 2 * e + 2 * i - h - k) % 7;
+	const m = Math.floor((a + 11 * h + 22 * l) / 451);
+	const month = Math.floor((h + l - 7 * m + 114) / 31);
+	const day = (h + l - 7 * m + 114) % 31 + 1;
+	return iso$4(year, month, day);
+}
+/** The nth given weekday (0 Sunday) of a month; n = -1 for the last. */
+function nth(year, month, dow, n) {
+	if (n > 0) {
+		const first = iso$4(year, month, 1);
+		const shift = (dow - weekday(first) + 7) % 7;
+		return plus(first, shift + (n - 1) * 7);
+	}
+	const last = iso$4(year, month + 1, 0);
+	return plus(last, -((weekday(last) - dow + 7) % 7));
+}
+/** The given weekday on or before a day. */
+const onOrBefore = (day, dow) => plus(day, -((weekday(day) - dow + 7) % 7));
+const fixed = (m, d) => (y) => iso$4(y, m, d);
+const fromEaster = (n) => (y) => plus(easter(y), n);
+/** New Zealand's Matariki, set by law for each year. */
+const MATARIKI = {
+	2025: "2025-06-20",
+	2026: "2026-07-10",
+	2027: "2027-06-25",
+	2028: "2028-07-14",
+	2029: "2029-07-06",
+	2030: "2030-06-21",
+	2031: "2031-07-11",
+	2032: "2032-07-02",
+	2033: "2033-06-24",
+	2034: "2034-07-07",
+	2035: "2035-06-29"
+};
+const RULES = {
+	US: [
+		[
+			"New Year's Day",
+			fixed(1, 1),
+			"us"
+		],
+		["Martin Luther King Jr. Day", (y) => nth(y, 1, 1, 3)],
+		["Presidents' Day", (y) => nth(y, 2, 1, 3)],
+		["Memorial Day", (y) => nth(y, 5, 1, -1)],
+		[
+			"Juneteenth",
+			fixed(6, 19),
+			"us"
+		],
+		[
+			"Independence Day",
+			fixed(7, 4),
+			"us"
+		],
+		["Labor Day", (y) => nth(y, 9, 1, 1)],
+		["Thanksgiving", (y) => nth(y, 11, 4, 4)],
+		[
+			"Christmas Day",
+			fixed(12, 25),
+			"us"
+		]
+	],
+	CA: [
+		[
+			"New Year's Day",
+			fixed(1, 1),
+			"next"
+		],
+		["Good Friday", fromEaster(-2)],
+		["Victoria Day", (y) => onOrBefore(iso$4(y, 5, 24), 1)],
+		[
+			"Canada Day",
+			fixed(7, 1),
+			"next"
+		],
+		["Labour Day", (y) => nth(y, 9, 1, 1)],
+		["Thanksgiving", (y) => nth(y, 10, 1, 2)],
+		[
+			"Christmas Day",
+			fixed(12, 25),
+			"next"
+		],
+		[
+			"Boxing Day",
+			fixed(12, 26),
+			"next"
+		]
+	],
+	GB: [
+		[
+			"New Year's Day",
+			fixed(1, 1),
+			"next"
+		],
+		["Good Friday", fromEaster(-2)],
+		["Easter Monday", fromEaster(1)],
+		["Early May bank holiday", (y) => nth(y, 5, 1, 1)],
+		["Spring bank holiday", (y) => nth(y, 5, 1, -1)],
+		["Summer bank holiday", (y) => nth(y, 8, 1, -1)],
+		[
+			"Christmas Day",
+			fixed(12, 25),
+			"next"
+		],
+		[
+			"Boxing Day",
+			fixed(12, 26),
+			"next"
+		]
+	],
+	IE: [
+		[
+			"New Year's Day",
+			fixed(1, 1),
+			"next"
+		],
+		["St Brigid's Day", (y) => weekday(iso$4(y, 2, 1)) === 5 ? iso$4(y, 2, 1) : nth(y, 2, 1, 1)],
+		[
+			"St Patrick's Day",
+			fixed(3, 17),
+			"next"
+		],
+		["Easter Monday", fromEaster(1)],
+		["May bank holiday", (y) => nth(y, 5, 1, 1)],
+		["June bank holiday", (y) => nth(y, 6, 1, 1)],
+		["August bank holiday", (y) => nth(y, 8, 1, 1)],
+		["October bank holiday", (y) => nth(y, 10, 1, -1)],
+		[
+			"Christmas Day",
+			fixed(12, 25),
+			"next"
+		],
+		[
+			"St Stephen's Day",
+			fixed(12, 26),
+			"next"
+		]
+	],
+	AU: [
+		[
+			"New Year's Day",
+			fixed(1, 1),
+			"next"
+		],
+		[
+			"Australia Day",
+			fixed(1, 26),
+			"next"
+		],
+		["Good Friday", fromEaster(-2)],
+		["Easter Monday", fromEaster(1)],
+		["Anzac Day", fixed(4, 25)],
+		["King's Birthday", (y) => nth(y, 6, 1, 2)],
+		[
+			"Christmas Day",
+			fixed(12, 25),
+			"next"
+		],
+		[
+			"Boxing Day",
+			fixed(12, 26),
+			"next"
+		]
+	],
+	NZ: [
+		[
+			"New Year's Day",
+			fixed(1, 1),
+			"next"
+		],
+		[
+			"Day after New Year's Day",
+			fixed(1, 2),
+			"next"
+		],
+		[
+			"Waitangi Day",
+			fixed(2, 6),
+			"next"
+		],
+		["Good Friday", fromEaster(-2)],
+		["Easter Monday", fromEaster(1)],
+		[
+			"Anzac Day",
+			fixed(4, 25),
+			"next"
+		],
+		["King's Birthday", (y) => nth(y, 6, 1, 1)],
+		["Matariki", (y) => MATARIKI[y] ?? ""],
+		["Labour Day", (y) => nth(y, 10, 1, 4)],
+		[
+			"Christmas Day",
+			fixed(12, 25),
+			"next"
+		],
+		[
+			"Boxing Day",
+			fixed(12, 26),
+			"next"
+		]
+	],
+	DE: [
+		["Neujahr", fixed(1, 1)],
+		["Karfreitag", fromEaster(-2)],
+		["Ostermontag", fromEaster(1)],
+		["Tag der Arbeit", fixed(5, 1)],
+		["Christi Himmelfahrt", fromEaster(39)],
+		["Pfingstmontag", fromEaster(50)],
+		["Tag der Deutschen Einheit", fixed(10, 3)],
+		["1. Weihnachtstag", fixed(12, 25)],
+		["2. Weihnachtstag", fixed(12, 26)]
+	],
+	FR: [
+		["Jour de l'an", fixed(1, 1)],
+		["Lundi de Pâques", fromEaster(1)],
+		["Fête du Travail", fixed(5, 1)],
+		["Victoire 1945", fixed(5, 8)],
+		["Ascension", fromEaster(39)],
+		["Lundi de Pentecôte", fromEaster(50)],
+		["Fête nationale", fixed(7, 14)],
+		["Assomption", fixed(8, 15)],
+		["Toussaint", fixed(11, 1)],
+		["Armistice", fixed(11, 11)],
+		["Noël", fixed(12, 25)]
+	],
+	NL: [
+		["Nieuwjaarsdag", fixed(1, 1)],
+		["Tweede paasdag", fromEaster(1)],
+		["Koningsdag", (y) => weekday(iso$4(y, 4, 27)) === 0 ? iso$4(y, 4, 26) : iso$4(y, 4, 27)],
+		["Hemelvaartsdag", fromEaster(39)],
+		["Tweede pinksterdag", fromEaster(50)],
+		["Eerste kerstdag", fixed(12, 25)],
+		["Tweede kerstdag", fixed(12, 26)]
+	],
+	ES: [
+		["Año Nuevo", fixed(1, 1)],
+		["Epifanía", fixed(1, 6)],
+		["Viernes Santo", fromEaster(-2)],
+		["Fiesta del Trabajo", fixed(5, 1)],
+		["Asunción", fixed(8, 15)],
+		["Fiesta Nacional", fixed(10, 12)],
+		["Todos los Santos", fixed(11, 1)],
+		["Día de la Constitución", fixed(12, 6)],
+		["Inmaculada Concepción", fixed(12, 8)],
+		["Navidad", fixed(12, 25)]
+	],
+	IT: [
+		["Capodanno", fixed(1, 1)],
+		["Epifania", fixed(1, 6)],
+		["Lunedì dell'Angelo", fromEaster(1)],
+		["Festa della Liberazione", fixed(4, 25)],
+		["Festa del Lavoro", fixed(5, 1)],
+		["Festa della Repubblica", fixed(6, 2)],
+		["Ferragosto", fixed(8, 15)],
+		["Ognissanti", fixed(11, 1)],
+		["Immacolata Concezione", fixed(12, 8)],
+		["Natale", fixed(12, 25)],
+		["Santo Stefano", fixed(12, 26)]
+	],
+	MX: [
+		["Año Nuevo", fixed(1, 1)],
+		["Día de la Constitución", (y) => nth(y, 2, 1, 1)],
+		["Natalicio de Benito Juárez", (y) => nth(y, 3, 1, 3)],
+		["Día del Trabajo", fixed(5, 1)],
+		["Día de la Independencia", fixed(9, 16)],
+		["Día de la Revolución", (y) => nth(y, 11, 1, 3)],
+		["Navidad", fixed(12, 25)]
+	],
+	BR: [
+		["Confraternização Universal", fixed(1, 1)],
+		["Carnaval", fromEaster(-48)],
+		["Carnaval", fromEaster(-47)],
+		["Sexta-feira Santa", fromEaster(-2)],
+		["Tiradentes", fixed(4, 21)],
+		["Dia do Trabalho", fixed(5, 1)],
+		["Corpus Christi", fromEaster(60)],
+		["Independência", fixed(9, 7)],
+		["Nossa Senhora Aparecida", fixed(10, 12)],
+		["Finados", fixed(11, 2)],
+		["Proclamação da República", fixed(11, 15)],
+		["Consciência Negra", fixed(11, 20)],
+		["Natal", fixed(12, 25)]
+	]
+};
+const cache = /* @__PURE__ */ new Map();
+/** A country's public holidays in a year, by the day they're taken, oldest first. */
+function holidaysIn(country, year) {
+	const key = `${country}|${year}`;
+	const had = cache.get(key);
+	if (had) return had;
+	const days = (RULES[country] ?? []).map(([name, day, move = "none"]) => ({
+		name,
+		date: day(year),
+		move
+	})).filter((h) => h.date);
+	const taken = new Set(days.filter((h) => !isWeekend(h.date)).map((h) => h.date));
+	const out = [];
+	for (const h of days) {
+		let date = h.date;
+		const wd = weekday(date);
+		if (h.move === "us" && (wd === 0 || wd === 6)) date = plus(date, wd === 6 ? -1 : 1);
+		else if (h.move === "next" && (wd === 0 || wd === 6)) {
+			date = plus(date, 1);
+			while (taken.has(date) || isWeekend(date)) date = plus(date, 1);
+			taken.add(date);
+		}
+		out.push({
+			date,
+			name: h.name,
+			country
+		});
+	}
+	out.sort((a, b) => a.date.localeCompare(b.date));
+	cache.set(key, out);
+	return out;
+}
+/** Holidays in the given countries between two days, both included. */
+function holidaysBetween(countries, from, to) {
+	const out = [];
+	const y0 = Number(from.slice(0, 4));
+	const y1 = Number(to.slice(0, 4));
+	for (const c of countries) for (let y = y0; y <= y1; y++) for (const h of holidaysIn(c, y)) if (h.date >= from && h.date <= to) out.push(h);
+	return out.sort((a, b) => a.date.localeCompare(b.date) || a.country.localeCompare(b.country));
+}
+/** Days someone is away: from the handover day up to the day before they're back. */
+function awayDays(person) {
+	const a = person.away;
+	if (!a?.until || !a.since) return null;
+	return [a.since.slice(0, 10), plus(a.until, -1)];
+}
+/** The harbor's calendar of who works when; see the top of this file. */
+function workCalendar(data) {
+	const harbor = (data.workCalendar?.countries ?? []).filter((c) => countryCode(c) === c);
+	const people = new Map(data.people.map((p) => [p.id, p]));
+	const own = (id) => {
+		const c = id ? countryCode(people.get(id)?.country) : null;
+		return c ? [c] : harbor;
+	};
+	const byDay = /* @__PURE__ */ new Map();
+	const holidayOn = (countries, day) => {
+		const year = Number(day.slice(0, 4));
+		for (const c of countries) {
+			const k = `${c}|${year}`;
+			let days = byDay.get(k);
+			if (!days) {
+				days = new Map(holidaysIn(c, year).map((h) => [h.date, h]));
+				byDay.set(k, days);
+			}
+			const h = days.get(day);
+			if (h) return h;
+		}
+		return null;
+	};
+	const offOn = (personId, day) => {
+		if (isWeekend(day)) return null;
+		const person = personId ? people.get(personId) : void 0;
+		const away = person ? awayDays(person) : null;
+		if (away && day >= away[0] && day <= away[1]) return { kind: "away" };
+		const h = holidayOn(own(personId), day);
+		return h ? {
+			kind: "holiday",
+			name: h.name,
+			country: h.country
+		} : null;
+	};
+	return {
+		countries: harbor,
+		countriesOf: own,
+		offOn,
+		works: (personId, day) => !isWeekend(day) && offOn(personId, day) === null,
+		active: harbor.length > 0 || data.people.some((p) => countryCode(p.country) || awayDays(p) !== null)
+	};
+}
+/** A calendar where nobody has holidays or time away: Monday to Friday. */
+const PLAIN_CALENDAR = workCalendar({ people: [] });
+/**
+* The public holidays anyone in the harbor takes between two days, one
+* entry a day: "Christmas Day (GB, US)". For views that aren't one person's,
+* like the timeline.
+*/
+function harborHolidays(data, from, to) {
+	const countries = new Set(workCalendar(data).countries);
+	for (const p of data.people) {
+		const c = countryCode(p.country);
+		if (c) countries.add(c);
+	}
+	const byDay = /* @__PURE__ */ new Map();
+	for (const h of holidaysBetween([...countries], from, to)) {
+		if (isWeekend(h.date)) continue;
+		byDay.set(h.date, [...byDay.get(h.date) ?? [], h]);
+	}
+	return [...byDay].map(([date, hs]) => {
+		const names = [...new Set(hs.map((h) => h.name))];
+		const codes = hs.map((h) => h.country).join(", ");
+		return {
+			date,
+			names: `${names.join(" / ")} (${codes})`
+		};
+	});
+}
+
 //#endregion
 //#region src/lib/tide.ts
 init_date_fns();
 init_format();
-init_soundings();
 /**
 * The tide forecast: when a project will likely finish, from how fast its
 * crew has actually closed tasks. Each of a thousand runs replays the coming
@@ -3815,7 +4317,7 @@ function random(seed) {
 	};
 }
 /** Days from today to finishing, one per run; Infinity for a run that never does. */
-function simulate(remaining, weekly, seed, pace = 1) {
+function simulate(remaining, weekly, seed, pace = 1, shares = null) {
 	const next = random(seed);
 	const out = [];
 	for (let run = 0; run < TRIALS; run++) {
@@ -3823,7 +4325,12 @@ function simulate(remaining, weekly, seed, pace = 1) {
 		let days = Infinity;
 		for (let week = 0; week < MAX_WEEKS; week++) {
 			const drawn = weekly[Math.floor(next() * weekly.length)];
-			const closed = pace === 1 ? drawn : Math.floor(drawn * pace) + (next() < drawn * pace % 1 ? 1 : 0);
+			let closed = pace === 1 ? drawn : Math.floor(drawn * pace) + (next() < drawn * pace % 1 ? 1 : 0);
+			const share = shares ? shares(week) : 1;
+			if (share < 1 && closed > 0) {
+				const scaled = closed * share;
+				closed = Math.floor(scaled) + (next() < scaled - Math.floor(scaled) ? 1 : 0);
+			}
 			if (closed >= left) {
 				const landed = Array.from({ length: closed }, () => 1 + Math.floor(next() * 7));
 				landed.sort((a, b) => a - b);
@@ -3841,7 +4348,7 @@ function simulate(remaining, weekly, seed, pace = 1) {
 * answers at random, so a wide spread widens the forecast. A task already
 * in play counts half its days; it's partly done.
 */
-function soundingFloors(tasks, reflections, base, seed) {
+function soundingFloors(tasks, reflections, base, seed, calendar) {
 	const draws = [];
 	for (const t of tasks) {
 		if (t.status === "done") continue;
@@ -3849,7 +4356,8 @@ function soundingFloors(tasks, reflections, base, seed) {
 		if (days.length === 0) continue;
 		draws.push({
 			days,
-			share: t.status === "doing" || t.status === "review" ? .5 : 1
+			share: t.status === "doing" || t.status === "review" ? .5 : 1,
+			who: t.assigneeId
 		});
 	}
 	if (draws.length === 0) return {
@@ -3858,9 +4366,13 @@ function soundingFloors(tasks, reflections, base, seed) {
 	};
 	const next = random(seed);
 	const memo = /* @__PURE__ */ new Map();
-	const ahead = (d) => {
-		let v = memo.get(d);
-		if (v === void 0) memo.set(d, v = workingDaysAhead(d, base));
+	const ahead = (d, who) => {
+		const k = `${who}|${d}`;
+		let v = memo.get(k);
+		if (v === void 0) {
+			const works = calendar?.active ? (at) => calendar.works(who, todayISO(at)) : void 0;
+			memo.set(k, v = workingDaysAhead(d, base, works));
+		}
 		return v;
 	};
 	const floors = [];
@@ -3868,7 +4380,7 @@ function soundingFloors(tasks, reflections, base, seed) {
 		let most = 0;
 		for (const x of draws) {
 			const d = x.days[Math.floor(next() * x.days.length)] * x.share;
-			most = Math.max(most, ahead(d));
+			most = Math.max(most, ahead(d, x.who));
 		}
 		floors.push(most);
 	}
@@ -3878,6 +4390,79 @@ function soundingFloors(tasks, reflections, base, seed) {
 	};
 }
 /**
+* Each coming week's share of the crew's usual working days, from day 1
+* (tomorrow): who owns the open tasks, less their holidays and time away.
+* Null when the calendar has nothing in it, so the forecast reads as before.
+*/
+function weekShares(tasks, base, calendar) {
+	const crew = [...new Set(tasks.filter((t) => t.status !== "done").map((t) => t.assigneeId))].filter((id) => id !== null);
+	const people = crew.length ? crew : [null];
+	if (!calendar?.active) return {
+		shares: null,
+		crew: people
+	};
+	const known = [];
+	const share = (week) => {
+		const had = known[week];
+		if (had !== void 0) return had;
+		let usual = 0;
+		let working = 0;
+		for (let d = week * 7 + 1; d <= week * 7 + 7; d++) {
+			const day = todayISO(addDays(base, d));
+			const wd = addDays(base, d).getDay();
+			if (wd === 0 || wd === 6) continue;
+			for (const p of people) {
+				usual++;
+				if (calendar.works(p, day)) working++;
+			}
+		}
+		return known[week] = usual ? working / usual : 1;
+	};
+	return {
+		shares: share,
+		crew: people
+	};
+}
+/** The holidays and away days the crew has between tomorrow and `until`. */
+function ashoreUntil(calendar, crew, base, until) {
+	const holidays = [];
+	let awayDays = 0;
+	if (!calendar?.active || !Number.isFinite(until)) return {
+		holidays,
+		awayDays
+	};
+	const seen = /* @__PURE__ */ new Set();
+	for (let d = 1; d <= until; d++) {
+		const day = todayISO(addDays(base, d));
+		for (const p of crew) {
+			const off = calendar.offOn(p, day);
+			if (off?.kind === "away") awayDays++;
+			else if (off?.kind === "holiday" && !seen.has(`${day}|${off.country}`)) {
+				seen.add(`${day}|${off.country}`);
+				holidays.push({
+					date: day,
+					name: off.name,
+					country: off.country
+				});
+			}
+		}
+	}
+	return {
+		holidays,
+		awayDays
+	};
+}
+/** What the forecast reads beyond the tasks: soundings and the work calendar. */
+function tideOptions(data) {
+	return {
+		reflections: data.reflections,
+		calendar: workCalendar({
+			people: data.people ?? [],
+			workCalendar: data.workCalendar
+		})
+	};
+}
+/**
 * `pace` scales the crew's weekly counts (1 is as they are), for dry dock's
 * "what if Sam joined" (src/lib/dry-dock.ts).
 */
@@ -3896,7 +4481,8 @@ function tideForecast(project, tasks, now, opts = {}) {
 	};
 	const today = todayISO(now);
 	const base = noon$2(today);
-	const paced = simulate(remaining, weekly, hash(`${project.id}|${remaining}|${today}`), Math.max(0, opts.pace ?? 1));
+	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)];
 	let lastDue = null;
 	for (const t of tasks) {
@@ -3904,7 +4490,7 @@ function tideForecast(project, tasks, now, opts = {}) {
 		if (!lastDue || t.dueDate > lastDue.dueDate) lastDue = t;
 	}
 	const floor = lastDue ? differenceInCalendarDays(noon$2(lastDue.dueDate), base) : 0;
-	const sounded = soundingFloors(tasks, opts.reflections, base, hash(`${project.id}|sound|${today}`));
+	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;
@@ -3934,7 +4520,8 @@ function tideForecast(project, tasks, now, opts = {}) {
 		curve,
 		rough: finished < ROUGH_BELOW,
 		heldBy,
-		sounded: sounded.sounded
+		sounded: sounded.sounded,
+		ashore: ashoreUntil(opts.calendar, crew, base, at(.85))
 	};
 }
 /** "15%", with "under 5%" and "over 95%" at the ends, where a thousand runs can't be that sure. */
@@ -4689,9 +5276,10 @@ function slipHeadline(cost) {
 */
 function programSlipCost(data, programId, now) {
 	let sum = 0;
+	const opts = tideOptions(data);
 	for (const p of data.projects) {
 		if (p.programId !== programId || p.budget <= 0 || p.health === "done") continue;
-		const tide = tideForecast(p, tasksOf(data.tasks, p.id), now);
+		const tide = tideForecast(p, tasksOf(data.tasks, p.id), now, opts);
 		sum += slipCost(p, tide, spendEntriesOf(data, p.id), now)?.likely?.cost ?? 0;
 	}
 	return sum;
@@ -4966,7 +5554,7 @@ function filterTasks(tasks, f) {
 */
 function tideLine(data, project, today) {
 	const tasks = tasksOf(data.tasks, project.id);
-	const tide = tideForecast(project, tasks, parseIso(`${today}T12:00:00`), { reflections: data.reflections });
+	const tide = tideForecast(project, tasks, parseIso(`${today}T12:00:00`), tideOptions(data));
 	if (tide.kind === "no-pace") return {
 		text: "No forecast yet: nothing finished in the last few weeks",
 		late: false
@@ -5373,7 +5961,7 @@ function keepText(keep, now) {
 */
 function slipLine(data, project, today) {
 	const now = parseIso(`${today}T12:00:00`);
-	const tide = tideForecast(project, tasksOf(data.tasks, project.id), now);
+	const tide = tideForecast(project, tasksOf(data.tasks, project.id), now, tideOptions(data));
 	const cost = slipCost(project, tide, spendEntriesOf(data, project.id), now);
 	if (!cost?.likely || cost.likely.daysLate <= 0) return null;
 	return slipHeadline(cost);
@@ -8843,14 +9431,28 @@ function InboxView({ active, width, height, go }) {
 //#endregion
 //#region src/lib/load.ts
 /** Open tasks for one person, bucketed by the week they are due, plus what is already late or has no date. */
-function weeklyLoad(tasks, personId, now, weeks = 6) {
+function weeklyLoad(tasks, personId, now, weeks = 6, calendar) {
 	const mine = tasks.filter((t) => t.assigneeId === personId && t.status !== "done");
 	const today = iso$2(now);
 	const origin = startOfWeek(now, { weekStartsOn: 1 });
-	const buckets = Array.from({ length: weeks }, (_, i) => ({
-		start: iso$2(addDays(origin, i * 7)),
-		due: 0
-	}));
+	const buckets = Array.from({ length: weeks }, (_, i) => {
+		const start = iso$2(addDays(origin, i * 7));
+		const off = [];
+		if (calendar?.active) for (let d = 0; d < 5; d++) {
+			const date = iso$2(addDays(origin, i * 7 + d));
+			const why = calendar.offOn(personId, date);
+			if (why) off.push({
+				date,
+				why
+			});
+		}
+		return {
+			start,
+			due: 0,
+			workDays: 5 - off.length,
+			off
+		};
+	});
 	let overdue = 0;
 	let undated = 0;
 	for (const t of mine) {
@@ -18225,8 +18827,8 @@ const STATUSES = [
 * for an agent: dates for half, 85% and 95% of the runs, or why there's none.
 * Given the spend ledger, also what each week late costs (src/lib/slip-cost.ts).
 */
-function finishForecast(project, tasks, now, spend, reflections) {
-	const tide = tideForecast(project, tasks, now, { reflections });
+function finishForecast(project, tasks, now, spend, data) {
+	const tide = tideForecast(project, tasks, now, data ? tideOptions(data) : {});
 	if (tide.kind !== "forecast") return { none: tideQuiet(tide) };
 	const lastDue = dueAfterFinish(tide);
 	const dueLater = lastDue ? { lastDue: {
@@ -18253,6 +18855,14 @@ function finishForecast(project, tasks, now, spend, reflections) {
 		basedOn: `${tide.finished} task${tide.finished === 1 ? "" : "s"} finished in the last ${tide.weeks} week${tide.weeks === 1 ? "" : "s"}`,
 		...tide.rough ? { rough: true } : {},
 		...tide.sounded ? { soundedTasks: tide.sounded } : {},
+		...tide.ashore.holidays.length || tide.ashore.awayDays ? { timeAshore: {
+			holidays: tide.ashore.holidays.map((h) => ({
+				date: h.date,
+				name: h.name,
+				country: h.country
+			})),
+			awayDays: tide.ashore.awayDays
+		} } : {},
 		...tide.weeks < 2 ? { shortHistory: true } : {},
 		...dueLater,
 		...slip
@@ -18684,7 +19294,7 @@ const HARBOR_TOOLS = [
 							done: c.done,
 							late: c.late
 						},
-						finish: finishForecast(p, tasksOf(data.tasks, p.id), ctx.now, spendBy.get(p.id) ?? [], data.reflections),
+						finish: finishForecast(p, tasksOf(data.tasks, p.id), ctx.now, spendBy.get(p.id) ?? [], data),
 						...limitsOf(data, p.id),
 						...hillOf(p, today),
 						...publicRoadmap(ctx, p.id)
@@ -18755,7 +19365,7 @@ const HARBOR_TOOLS = [
 				waitsOn,
 				milestones,
 				openRaid: raid,
-				finish: finishForecast(p, tasks, ctx.now, spendEntriesOf(data, p.id), data.reflections),
+				finish: finishForecast(p, tasks, ctx.now, spendEntriesOf(data, p.id), data),
 				...charterOf(p, tasks),
 				...notesOf(ctx, p),
 				...hillOf(p, today),
@@ -19258,6 +19868,40 @@ const HARBOR_TOOLS = [
 			};
 		}
 	}),
+	tool({
+		name: "time_ashore",
+		title: "Time ashore",
+		description: "Whose public holidays the harbor takes (country codes), anyone who takes another country's, and the days off coming up: public holidays, and who is away and when they're back. The forecast and the weekly load count these as days nobody works." + DATA_NOTE,
+		input: object({
+			harbor: harborArg,
+			days: number().int().min(1).max(366).default(56).describe("How far ahead to look, in days.")
+		}),
+		run: (ctx, input) => {
+			const { data } = ctx;
+			const today = todayISO(ctx.now);
+			const until = plus(today, input.days);
+			return {
+				countries: workCalendar(data).countries.map((c) => ({
+					code: c,
+					name: countryName(c)
+				})),
+				people: data.people.filter((p) => countryCode(p.country)).map((p) => ({
+					name: p.name,
+					country: countryCode(p.country)
+				})),
+				holidays: harborHolidays(data, today, until).map((h) => ({
+					date: h.date,
+					name: h.names
+				})),
+				away: data.people.filter((p) => p.away?.since && p.away.until > today && p.away.since.slice(0, 10) <= until).map((p) => ({
+					name: p.name,
+					from: p.away.since.slice(0, 10),
+					back: p.away.until
+				})),
+				known: COUNTRIES.map((c) => c.code)
+			};
+		}
+	}),
 	tool({
 		name: "long_pole",
 		title: "What's holding this up",
@@ -19566,7 +20210,8 @@ function pickData(s) {
 		checkIns: s.checkIns ?? NONE,
 		spendEntries: s.spendEntries ?? NONE,
 		reflections: s.reflections ?? NONE,
-		priorityRules: s.priorityRules ?? null
+		priorityRules: s.priorityRules ?? null,
+		workCalendar: s.workCalendar ?? null
 	};
 }
 /** The document as sent to the server: normalized and without inline file data. */
@@ -21845,6 +22490,19 @@ function peopleSpendSlice({ set, get, write }) {
 				...patch
 			} : p) });
 		},
+		setHolidayCountries: (codes) => {
+			const countries = [...new Set(codes.map((c) => countryCode(c)).filter((c) => c !== null))].slice(0, 12);
+			write({ workCalendar: countries.length ? { countries } : null });
+		},
+		setPersonCountry: (id, code) => {
+			const country = code ? countryCode(code) : null;
+			if (code && !country) return false;
+			write({ people: get().people.map((p) => p.id === id ? {
+				...p,
+				country
+			} : p) });
+			return true;
+		},
 		addPerson: (p) => {
 			const id = uid("p");
 			const row = {
@@ -22028,6 +22686,7 @@ var init_people_spend = __esmMin((() => {
 	init_assignment();
 	init_spend();
 	init_utils();
+	init_countries();
 	init_shared();
 	init_allocation();
 }));
@@ -22153,7 +22812,7 @@ function pickCollections(doc, keys) {
 function emptyRows() {
 	return Object.fromEntries(ROW_COLLECTIONS.map((k) => [k, []]));
 }
-/** A collection as rows; `spendEntries`, `reflections` and `priorityRules` may be missing from older documents. */
+/** A collection as rows; `spendEntries`, `reflections`, `priorityRules` and `workCalendar` may be missing from older documents. */
 function rowsOf(doc, key) {
 	if (isKeyed(key)) return KEYED[key].rows(doc[key]);
 	return doc[key] ?? [];
@@ -22237,7 +22896,8 @@ var init_changes = __esmMin((() => {
 		"checkIns",
 		"spendEntries",
 		"reflections",
-		"priorityRules"
+		"priorityRules",
+		"workCalendar"
 	];
 	ROW_COLLECTIONS = [
 		"tasks",
@@ -22257,7 +22917,8 @@ var init_changes = __esmMin((() => {
 		"boardConfigs",
 		"ropes",
 		"readPingIds",
-		"priorityRules"
+		"priorityRules",
+		"workCalendar"
 	];
 	KEYED = {
 		boardConfigs: {
@@ -22288,6 +22949,17 @@ var init_changes = __esmMin((() => {
 				const { id: _id, ...rules } = rows[0];
 				return rules;
 			}
+		},
+		workCalendar: {
+			rows: (value) => value ? [{
+				...value,
+				id: "calendar"
+			}] : [],
+			value: (rows) => {
+				if (!rows[0]) return null;
+				const { id: _id, ...calendar } = rows[0];
+				return calendar;
+			}
 		}
 	};
 	isKeyed = (key) => key in KEYED;

package/lib/cli.mjs

@@ -39,6 +39,7 @@ import {
   lifeboatsText,
   followedText,
   soundingsText,
+  ashoreText,
   voyageText,
   whyText,
   handoverText,
@@ -213,12 +214,16 @@ export const HELP = `harbor: Harbor from the terminal
   harbor note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]
                                               a note for later: sealed until
                                               its day, milestone, or Off track
-  harbor sound TASK [DAYS] [--why TEXT] [--ask NAMES|crew] [--settle DAYS]
+  harbor sound TASK [--answer DAYS|--ask NAMES|--settle DAYS] [--why TEXT]
                                               a sounding: ask a few people how
                                               many days a task will take, give
                                               your answer, or read the spread
   harbor soundings [PROJECT]                  open tasks with a sounding, and
                                               the ones waiting on your answer
+  harbor ashore [--weeks N] [--country CODES|none] [--person NAME]
+                                              public holidays and time away
+                                              coming up, and whose holidays
+                                              the harbor (or someone) takes
   harbor handover PERSON [--to NAME] [--until DATE] [--note TEXT]
                          [--keep ID,ID] [--confirm]
                                               hand someone's work to the crew
@@ -449,6 +454,8 @@ const FLAG = {
   days: "the days",
   why: "--why",
   people: "--ask",
+  countries: "--country",
+  country: "--country",
 };
 
 /** Harbor's refusals are worded for agents; say them as the commands and flags that answer them. */
@@ -731,7 +738,8 @@ const DETAIL = {
     "  harbor sound TASK --ask crew           writes: asks you, its owner and whoever",
     "                                         has open work on its project",
     '  harbor sound TASK --ask "Sam,Priya"    writes: asks those people',
-    '  harbor sound TASK 4 [--why "TEXT"]     writes: your answer, in working days',
+    '  harbor sound TASK --answer 4 [--why "TEXT"]',
+    "                                         writes: your answer, in working days",
     "  harbor sound TASK --settle 6           writes: the days you agreed on after",
     "                                         talking a wide spread through",
     "",
@@ -739,6 +747,19 @@ const DETAIL = {
     "  everyone has. Close guesses give the task an estimate; far-apart ones",
     "  say talk first. The forecast draws on every answer.",
   ],
+  ashore: [
+    "  harbor ashore [--weeks N]              reads: holidays and time away in the",
+    "                                         next N weeks (8 unless you say)",
+    "  harbor ashore --country US,GB          writes: whose public holidays the",
+    "                                         harbor takes (none for no holidays)",
+    "  harbor ashore --person NAME --country GB",
+    "                                         writes: one person's own country",
+    "                                         (harbor to take the harbor's again)",
+    "",
+    "  The forecast, the weeks ahead, the timeline and calendar feeds count",
+    "  these as days nobody works. Countries: AU BR CA DE ES FR GB IE IT MX NL",
+    "  NZ US (national holidays only).",
+  ],
   soundings: [
     "  harbor soundings [PROJECT]             reads: open tasks with a sounding",
     "                                         (all projects when left out), and the",
@@ -2024,7 +2045,8 @@ export async function run(argv, io = {}) {
       );
       if (!values.project) throw new HarborError("Say which project: --project NAME.");
       // Several at once: one title a line on stdin, with no title (or -) after add.
-      const piped = positionals.length === 0 || (positionals.length === 1 && positionals[0] === "-");
+      const piped =
+        positionals.length === 0 || (positionals.length === 1 && positionals[0] === "-");
       const stdin = io.stdin ?? process.stdin;
       const titles =
         piped && (io.stdin || !process.stdin.isTTY)
@@ -2033,28 +2055,34 @@ export async function run(argv, io = {}) {
               .map((l) => l.trim())
               .filter(Boolean)
           : [text(positionals, "the task")];
-      if (titles.length === 0) throw new HarborError("Say the task, or give one title a line on stdin.");
-      if (titles.length > 100) throw new HarborError("That's more than 100 tasks; harbor import FILE takes a spreadsheet.");
+      if (titles.length === 0)
+        throw new HarborError("Say the task, or give one title a line on stdin.");
+      if (titles.length > 100)
+        throw new HarborError(
+          "That's more than 100 tasks; harbor import FILE takes a spreadsheet.",
+        );
       const added = [];
       for (const title of titles) {
-        const r = await client.call("create_task", {
-          harbor,
-          project: values.project,
-          title,
-          // Yours unless you say otherwise, as with n in the app.
-          assignee: values.assignee ?? "me",
-          due: duePilot(values.due) ? undefined : dueDate(values.due),
-          suggestedDue: duePilot(values.due),
-          priority: values.priority,
-          status: values.status === undefined ? undefined : statusWord(values.status),
-          overLimit: values["over-limit"] || undefined,
-        }).catch((err) => {
-          if (err instanceof HarborError) {
-            const done = added.length ? ` (added ${added.length} before it)` : "";
-            throw new HarborError(`${hint(err.message, values.project)}${done}`);
-          }
-          throw err;
-        });
+        const r = await client
+          .call("create_task", {
+            harbor,
+            project: values.project,
+            title,
+            // Yours unless you say otherwise, as with n in the app.
+            assignee: values.assignee ?? "me",
+            due: duePilot(values.due) ? undefined : dueDate(values.due),
+            suggestedDue: duePilot(values.due),
+            priority: values.priority,
+            status: values.status === undefined ? undefined : statusWord(values.status),
+            overLimit: values["over-limit"] || undefined,
+          })
+          .catch((err) => {
+            if (err instanceof HarborError) {
+              const done = added.length ? ` (added ${added.length} before it)` : "";
+              throw new HarborError(`${hint(err.message, values.project)}${done}`);
+            }
+            throw err;
+          });
         if (values.comment)
           r.comment = (
             await client.call("add_comment", {
@@ -2209,19 +2237,26 @@ export async function run(argv, io = {}) {
       const number = (v, name) => {
         if (v === undefined) return undefined;
         const n = Number(v);
-        if (!Number.isFinite(n) || n <= 0) throw new HarborError(`--${name} is a number of hours, like 2 or 1.5.`);
+        if (!Number.isFinite(n) || n <= 0)
+          throw new HarborError(`--${name} is a number of hours, like 2 or 1.5.`);
         return n;
       };
       const [task, day, ...extra] = positionals;
       if (extra.length) throw new HarborError("Give a task key and a day: harbor week RR-42 wed.");
       const dayHours = number(values["day-hours"], "day-hours");
-      const show = (r) => [r.done, weekText(r, { ...opts, review: Boolean(values.review) })].filter(Boolean).join("\n\n");
+      const show = (r) =>
+        [r.done, weekText(r, { ...opts, review: Boolean(values.review) })]
+          .filter(Boolean)
+          .join("\n\n");
       if (!task && dayHours === undefined) {
-        if (values.off || values.hours) throw new HarborError("Say which task: harbor week RR-42 wed --hours 3.");
+        if (values.off || values.hours)
+          throw new HarborError("Say which task: harbor week RR-42 wed --hours 3.");
         return call("get_week", { harbor, week }, show);
       }
       if (task && !day && !values.off)
-        throw new HarborError(`Say which day for ${task}: harbor week ${task} wed, or --off to take it off the week.`);
+        throw new HarborError(
+          `Say which day for ${task}: harbor week ${task} wed, or --off to take it off the week.`,
+        );
       return call(
         "plan_week",
         {
@@ -2485,9 +2520,14 @@ export async function run(argv, io = {}) {
       );
     }
     case "sound": {
-      const { positionals, values, harbor } = parse(spec([], ["why", "ask", "settle"]));
-      const [task, days, ...extra] = positionals;
+      const { positionals, values, harbor } = parse(spec([], ["answer", "why", "ask", "settle"]));
+      const [task, ...extra] = positionals;
       if (!task) throw new HarborError("Give a task's key, like harbor sound RR-4.");
+      // A bare number used to be the answer; it writes, so it now needs its flag.
+      if (extra.length === 1 && /^\d+(\.\d+)?(d|days?)?$/i.test(extra[0]))
+        throw new HarborError(
+          `To give your answer, say so: harbor sound ${task} --answer ${extra[0]}.`,
+        );
       if (extra.length) throw new HarborError(`Unexpected "${extra.join(" ")}".`);
       const number = (text) => {
         const n = Number(String(text).replace(/d(ays?)?$/i, ""));
@@ -2495,11 +2535,14 @@ export async function run(argv, io = {}) {
           throw new HarborError(`Give days as a number, like 3 or 2.5 (not "${text}").`);
         return n;
       };
+      const days = values.answer;
       const given = [days !== undefined, values.ask !== undefined, values.settle !== undefined];
       if (given.filter(Boolean).length > 1)
         throw new HarborError("Answer, ask or settle: one at a time.");
       if (values.why !== undefined && days === undefined)
-        throw new HarborError('--why goes with your answer: harbor sound TASK 4 --why "TEXT".');
+        throw new HarborError(
+          '--why goes with your answer: harbor sound TASK --answer 4 --why "TEXT".',
+        );
       if (values.ask !== undefined) {
         const crew = /^crew$/i.test(values.ask.trim())
           ? undefined
@@ -2507,11 +2550,10 @@ export async function run(argv, io = {}) {
               .split(",")
               .map((x) => x.trim())
               .filter(Boolean);
-        return call(
-          "take_sounding",
-          { harbor, task, ...(crew ? { people: crew } : {}) },
-          (r) =>
-            `Asked ${r.asked.people.join(", ")} how many days ${r.asked.key ?? r.asked.title} will take. The answers show together once everyone's in.`,
+        return call("take_sounding", { harbor, task, ...(crew ? { people: crew } : {}) }, (r) =>
+          !crew && r.asked.people.length === 1
+            ? `Only you are on this crew, so the sounding on ${r.asked.key ?? r.asked.title} is just your guess. Ask others by name: harbor sound ${task} --ask "Sam,Priya".`
+            : `Asked ${r.asked.people.join(", ")} how many days ${r.asked.key ?? r.asked.title} will take. The answers show together once everyone's in.`,
         );
       }
       if (values.settle !== undefined) {
@@ -2543,6 +2585,39 @@ export async function run(argv, io = {}) {
         soundingsText(r),
       );
     }
+    case "ashore": {
+      const { positionals, values, harbor } = parse(spec([], ["weeks", "country", "person"]));
+      none(positionals);
+      if (values.person && values.country === undefined)
+        throw new HarborError("Give their country too: --person NAME --country GB (or harbor).");
+      if (values.country !== undefined) {
+        if (values.person) {
+          return call(
+            "set_holidays",
+            { harbor, person: values.person, country: values.country },
+            (r) =>
+              r.country === "harbor"
+                ? `${r.person} takes the harbor's holidays.`
+                : `${r.person} takes ${r.country} holidays.`,
+          );
+        }
+        const countries = /^none$/i.test(values.country.trim())
+          ? []
+          : values.country
+              .split(",")
+              .map((c) => c.trim())
+              .filter(Boolean);
+        return call("set_holidays", { harbor, countries }, (r) =>
+          r.harbor.length
+            ? `The harbor takes public holidays from ${r.harbor.map((c) => c.name).join(", ")}.`
+            : "The harbor takes no public holidays now.",
+        );
+      }
+      const weeks = values.weeks === undefined ? 8 : Number(values.weeks);
+      if (!Number.isInteger(weeks) || weeks < 1 || weeks > 52)
+        throw new HarborError("--weeks is a whole number from 1 to 52.");
+      return call("time_ashore", { harbor, days: weeks * 7 }, (r) => ashoreText(r, weeks));
+    }
     case "why": {
       const { positionals, harbor } = parse(spec());
       const of = positionals.join(" ").trim();

package/lib/format.mjs

@@ -752,7 +752,7 @@ export function soundingText(task, s, { answered = false } = {}) {
     for (const a of s.answers)
       lines.push(`  You said ${daysText(a.days)}${a.why ? ` · "${a.why}"` : ""}`);
     if (s.youWereAsked && !s.answers.length)
-      lines.push(`  Give yours: harbor sound ${task.key ?? task.id} DAYS`);
+      lines.push(`  Give yours: harbor sound ${task.key ?? task.id} --answer DAYS`);
     return lines.join("\n");
   }
   lines.push(`  ${spreadLine(s.answers)}`);
@@ -768,6 +768,26 @@ export function soundingText(task, s, { answered = false } = {}) {
   return lines.join("\n");
 }
 
+/** time_ashore: whose holidays count, then the days off coming up, soonest first. */
+export function ashoreText(r, weeks = 8) {
+  const lines = [];
+  const countries = r.countries ?? [];
+  lines.push(
+    countries.length
+      ? `Time ashore · holidays from ${countries.map((c) => c.name).join(", ")}`
+      : "Time ashore · no holiday country set (harbor ashore --country US)",
+  );
+  for (const p of r.people ?? []) lines.push(`  ${p.name} takes ${p.country} holidays`);
+  const rows = [
+    ...(r.holidays ?? []).map((h) => [h.date, h.name]),
+    ...(r.away ?? []).map((a) => [a.from, `${a.name} away, back ${a.back}`]),
+  ].sort((a, b) => a[0].localeCompare(b[0]));
+  lines.push("");
+  if (!rows.length) lines.push(`  Nothing in the next ${weeks} weeks.`);
+  for (const [day, what] of rows) lines.push(`  ${day}  ${what}`);
+  return lines.join("\n");
+}
+
 /** list_soundings: the ones waiting on you first, then the rest, wide ones flagged. */
 export function soundingsText(r) {
   const all = r.soundings ?? [];

package/package.json

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