@harborppm/cli 0.58.0 → 0.60.0

package/dist/app.mjs

@@ -2278,6 +2278,1043 @@ var init_premortem = __esmMin((() => {
 	STOP = new Set("the a an and or but of to in on for with at by from into onto was were be been being is are it its this that these those we our us they them their he she his her i my me you your had has have did do does not no so too very just than then there here what which who because about after before over under again more most some any all each other only own same can could would should will got get project failed happened went".split(" "));
 }));
 
+//#endregion
+//#region src/lib/soundings.ts
+/** Why a number can't be an answer, or null when it can: half days up to SOUNDING_MAX_DAYS. */
+function daysProblem(days) {
+	if (!Number.isFinite(days) || days <= 0) return "Give a number of days above 0, like 3 or 0.5.";
+	if (days > 250) return `Keep it to ${250} working days or fewer.`;
+	if (Math.round(days * 2) !== days * 2) return "Use whole or half days, like 3 or 2.5.";
+	return null;
+}
+/** Each asked person's latest answer to the task's current sounding, oldest first. */
+function answersFor(reflections, task) {
+	const s = task.sounding;
+	if (!s) return [];
+	const crew = new Set(s.crewIds);
+	const latest = /* @__PURE__ */ new Map();
+	for (const r of reflections ?? []) {
+		if (r.kind !== "sounding" || r.taskId !== task.id || typeof r.days !== "number") continue;
+		if (r.createdAt < s.askedAt || !crew.has(r.authorId)) continue;
+		const had = latest.get(r.authorId);
+		if (!had || r.createdAt >= had.createdAt) latest.set(r.authorId, r);
+	}
+	return [...latest.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+/** Middle of the guesses, to the half day. */
+function middleOf(days) {
+	if (days.length === 0) return null;
+	const sorted = [...days].sort((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	const m = sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+	return Math.round(m * 2) / 2;
+}
+/**
+* Guesses far enough apart to talk about first: the highest at least twice
+* the lowest and three or more days from it. 3 against 5 is agreement; 2
+* against 15, or 5 against 10, is two people seeing different work.
+*/
+function isWide(days) {
+	if (days.length < 2) return false;
+	const low = Math.min(...days);
+	const high = Math.max(...days);
+	return high - low >= 3 && high >= low * 2;
+}
+/** Where a task's sounding stands, or null when nobody asked. */
+function readSounding(task, reflections, now) {
+	const s = task.sounding;
+	if (!s) return null;
+	const answers = answersFor(reflections, task);
+	const by = new Set(answers.map((a) => a.authorId));
+	const waitingOn = s.crewIds.filter((id) => !by.has(id));
+	const early = Boolean(s.shownAt && Date.parse(s.shownAt) <= now.getTime());
+	const shown = answers.length > 0 && (waitingOn.length === 0 || early);
+	const days = answers.map((a) => a.days);
+	const wide = shown && isWide(days);
+	const middle = middleOf(days);
+	const settled = s.settledDays ?? null;
+	return {
+		sounding: s,
+		crewIds: s.crewIds,
+		answers,
+		waitingOn,
+		shown,
+		low: days.length ? Math.min(...days) : null,
+		high: days.length ? Math.max(...days) : null,
+		middle,
+		wide,
+		estimate: settled ?? (shown && !wide ? middle : null)
+	};
+}
+/** What one person may see: their own answer always; everyone's once shown. */
+function visibleAnswers(read, personId) {
+	return read.shown ? read.answers : read.answers.filter((a) => a.authorId === personId);
+}
+/**
+* The answers the forecast draws from for an open task: the settled number
+* alone once there is one, otherwise every answer in so far (the spread is
+* the point, and the forecast names nobody's guess).
+*/
+function soundingDraws(task, reflections) {
+	const s = task.sounding;
+	if (!s) return [];
+	if (s.settledDays != null) return [s.settledDays];
+	return answersFor(reflections, task).map((a) => a.days);
+}
+/**
+* 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 && d < 730) {
+		d += 1;
+		const at = addDays(from, d);
+		const wd = at.getDay();
+		if (works ? works(at) : wd !== 0 && wd !== 6) left -= 1;
+	}
+	return d;
+}
+/** "half a day", "1 day", "2.5 days". */
+function daysText(days) {
+	if (days === .5) return "half a day";
+	return `${days} day${days === 1 ? "" : "s"}`;
+}
+/**
+* Who a new sounding asks unless you pick: you, the task's owner, and the
+* people with open work on its project, agents left out.
+*/
+function suggestedCrew(data, task, meId) {
+	const people = new Map(data.people.filter((p) => p.kind !== "agent").map((p) => [p.id, p]));
+	const out = /* @__PURE__ */ new Set();
+	if (people.has(meId)) out.add(meId);
+	if (task.assigneeId && people.has(task.assigneeId)) out.add(task.assigneeId);
+	for (const t of data.tasks) {
+		if (out.size >= 6) break;
+		if (t.projectId !== task.projectId || t.status === "done" || !t.assigneeId) continue;
+		if (people.has(t.assigneeId)) out.add(t.assigneeId);
+	}
+	return [...out];
+}
+/** "Close enough: about 4 days", or why it needs talking through. */
+function soundingVerdict(read) {
+	if (read.sounding.settledDays != null) return `Settled on ${daysText(read.sounding.settledDays)}.`;
+	if (read.wide) return `Talk about this first: guesses run from ${daysText(read.low)} to ${daysText(read.high)}, so someone sees work the others don't.`;
+	return `Close enough: about ${daysText(read.estimate)}.`;
+}
+/** Open tasks whose sounding waits on this person's answer. */
+function soundingsWaitingOn(data, personId, now) {
+	return data.tasks.filter((t) => {
+		if (t.status === "done" || !t.sounding?.crewIds.includes(personId)) return false;
+		return readSounding(t, data.reflections, now).waitingOn.includes(personId);
+	});
+}
+var SOUNDING_MAX_DAYS;
+var init_soundings = __esmMin((() => {
+	init_date_fns();
+	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
+/** 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$1(first, shift + (n - 1) * 7);
+	}
+	const last = iso$4(year, month + 1, 0);
+	return plus$1(last, -((weekday(last) - dow + 7) % 7));
+}
+/** 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$1(date, wd === 6 ? -1 : 1);
+		else if (h.move === "next" && (wd === 0 || wd === 6)) {
+			date = plus$1(date, 1);
+			while (taken.has(date) || isWeekend(date)) date = plus$1(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$1(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)
+	};
+}
+/**
+* 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})`
+		};
+	});
+}
+var iso$4, weekday, plus$1, isWeekend, onOrBefore, fixed, fromEaster, MATARIKI, RULES, cache, PLAIN_CALENDAR;
+var init_holidays = __esmMin((() => {
+	init_date_fns();
+	init_format();
+	init_countries();
+	iso$4 = (y, m, d) => todayISO(new Date(y, m - 1, d, 12));
+	weekday = (day) => (/* @__PURE__ */ new Date(`${day}T12:00:00`)).getDay();
+	plus$1 = (day, n) => todayISO(addDays(/* @__PURE__ */ new Date(`${day}T12:00:00`), n));
+	isWeekend = (day) => {
+		const wd = weekday(day);
+		return wd === 0 || wd === 6;
+	};
+	onOrBefore = (day, dow) => plus$1(day, -((weekday(day) - dow + 7) % 7));
+	fixed = (m, d) => (y) => iso$4(y, m, d);
+	fromEaster = (n) => (y) => plus$1(easter(y), n);
+	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"
+	};
+	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)]
+		]
+	};
+	cache = /* @__PURE__ */ new Map();
+	PLAIN_CALENDAR = workCalendar({ people: [] });
+}));
+
+//#endregion
+//#region 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 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 back = Math.max(0, differenceInCalendarDays(today, at));
+		const week = Math.floor(back / 7);
+		if (week < span) counts[span - 1 - week] += 1;
+	}
+	return counts;
+}
+function hash(text) {
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) {
+		h ^= text.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return h >>> 0;
+}
+/** mulberry32: small, fast, and the same everywhere for the same seed. */
+function random(seed) {
+	let a = seed;
+	return () => {
+		a = a + 1831565813 | 0;
+		let t = Math.imul(a ^ a >>> 15, 1 | a);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** Days from today to finishing, one per run; Infinity for a run that never does. */
+function simulate(remaining, weekly, seed, pace = 1, shares = null) {
+	const next = random(seed);
+	const out = [];
+	for (let run = 0; run < TRIALS; run++) {
+		let left = remaining;
+		let days = Infinity;
+		for (let week = 0; week < MAX_WEEKS; week++) {
+			const drawn = weekly[Math.floor(next() * weekly.length)];
+			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);
+				days = week * 7 + landed[left - 1];
+				break;
+			}
+			left -= closed;
+		}
+		out.push(days);
+	}
+	return out.sort((a, b) => a - b);
+}
+/**
+* Per run, the fewest days the sounded tasks allow: each draws one of its
+* 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, calendar) {
+	const draws = [];
+	for (const t of tasks) {
+		if (t.status === "done") continue;
+		const days = soundingDraws(t, reflections);
+		if (days.length === 0) continue;
+		draws.push({
+			days,
+			share: t.status === "doing" || t.status === "review" ? .5 : 1,
+			who: t.assigneeId
+		});
+	}
+	if (draws.length === 0) return {
+		floors: null,
+		sounded: 0
+	};
+	const next = random(seed);
+	const memo = /* @__PURE__ */ new Map();
+	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 = [];
+	for (let run = 0; run < TRIALS; run++) {
+		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, x.who));
+		}
+		floors.push(most);
+	}
+	return {
+		floors,
+		sounded: draws.length
+	};
+}
+/**
+* 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).
+*/
+function tideForecast(project, tasks, now, opts = {}) {
+	const remaining = tasks.filter((t) => t.status !== "done").length;
+	if (remaining === 0) return { kind: "done" };
+	if (project.health === "paused") return {
+		kind: "paused",
+		remaining
+	};
+	const weekly = weeklyFinished(tasks, project.startDate, now);
+	const finished = weekly.reduce((a, b) => a + b, 0);
+	if (finished === 0) return {
+		kind: "no-pace",
+		remaining
+	};
+	const today = todayISO(now);
+	const base = noon$3(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)];
+	let lastDue = null;
+	for (const t of tasks) {
+		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 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 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 = [];
+	const step = Math.max(1, Math.ceil(last / 60));
+	let i = 0;
+	for (let d = 0; d <= last; d += step) {
+		while (i < runs.length && runs[i] <= d) i++;
+		curve.push({
+			date: dayOf(d),
+			chance: i / runs.length
+		});
+	}
+	return {
+		kind: "forecast",
+		remaining,
+		finished,
+		weeks: weekly.length,
+		perWeek: Math.round(finished / weekly.length * Math.max(0, opts.pace ?? 1) * 10) / 10,
+		likely: dayOf(at(.5)),
+		veryLikely: dayOf(at(.85)),
+		almostCertain: dayOf(at(.95)),
+		chanceByEnd: Math.round(byEnd * 100) / 100,
+		curve,
+		rough: finished < ROUGH_BELOW,
+		heldBy,
+		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. */
+function chanceText(chance) {
+	if (chance < .05) return "under 5%";
+	if (chance > .95) return "over 95%";
+	return `${Math.round(chance * 20) * 5}%`;
+}
+/**
+* The open task whose due date sets the finish, when the crew's pace alone
+* would be done sooner; null otherwise.
+*/
+function dueAfterFinish(tide) {
+	return tide.kind === "forecast" ? tide.heldBy : null;
+}
+/** Why there's no forecast, for the states without one. */
+function tideQuiet(tide) {
+	switch (tide.kind) {
+		case "done": return "Every task is done.";
+		case "paused": return "Paused, so its pace says nothing about when it ends.";
+		case "no-pace": return `Nothing finished in the last ${6} weeks, so there's no pace to forecast from yet.`;
+		default: return null;
+	}
+}
+var TIDE_WEEKS, TRIALS, MAX_WEEKS, ROUGH_BELOW, noon$3;
+var init_tide = __esmMin((() => {
+	init_date_fns();
+	init_format();
+	init_soundings();
+	init_holidays();
+	TIDE_WEEKS = 6;
+	TRIALS = 1e3;
+	MAX_WEEKS = 104;
+	ROUGH_BELOW = 5;
+	noon$3 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+}));
+
+//#endregion
+//#region src/lib/barnacles.ts
+/**
+* When the plan was set: when the baseline was set, else a week after the
+* project's first task was made (the first week is the plan being written).
+*/
+function planSetAt(project, tasks) {
+	if (project.baselineAt) return {
+		since: project.baselineAt,
+		from: "baseline"
+	};
+	let first = null;
+	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`,
+		from: "start"
+	};
+}
+/**
+* A project's barnacles from its own tasks. `slip` is the days late being
+* explained (the forecast past the planned end, the end's move from the
+* baseline, or a finished project's days over), when there is one.
+*/
+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));
+	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 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 slot = weeks[Math.min(Math.max(0, i), weeks.length - 1)];
+		if (slot) slot.added += 1;
+		const who = t.createdById ?? null;
+		counts.set(who, (counts.get(who) ?? 0) + 1);
+	}
+	const names = new Map(people.map((p) => [p.id, p.name]));
+	const adders = [...counts].map(([personId, n]) => ({
+		personId: personId && names.has(personId) ? personId : null,
+		name: personId && names.get(personId) || "not recorded",
+		added: n
+	})).sort((a, b) => (a.personId == null ? 1 : 0) - (b.personId == null ? 1 : 0) || b.added - a.added);
+	const weekly = weeklyFinished(tasks, project.startDate, now);
+	const finished = weekly.reduce((a, b) => a + b, 0);
+	const perWeek = finished > 0 ? Math.round(finished / weekly.length * 10) / 10 : null;
+	return {
+		since,
+		from,
+		planned,
+		added: added.length,
+		share: planned > 0 ? added.length / planned : null,
+		thisWeek: added.filter((t) => t.createdAt.slice(0, 10) > weekAgo).length,
+		weeks,
+		adders,
+		perWeek,
+		days: perWeek ? Math.round(added.length / perWeek * 7) : null,
+		slip
+	};
+}
+/**
+* Days a project is running late against its plan: the likely finish at the
+* crew's pace past the planned end (the baseline's, else the end date), or
+* how far the end date itself has moved from the baseline; null when neither.
+*/
+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 slip = Math.max(likely, moved);
+	return slip > 0 ? slip : null;
+}
+/** "+14 tasks since the baseline, 38% more than planned"; null when nothing was added. */
+function barnaclesHeadline(b) {
+	if (b.added === 0) return null;
+	const when = b.from === "baseline" ? "since the baseline" : "since its first week";
+	const pct = b.share != null ? `, ${Math.round(b.share * 100)}% more than planned` : "";
+	return `+${plural$5(b.added, "task")} ${when}${pct}`;
+}
+/** What the added work costs in days, and how much of the slip it explains. */
+function barnaclesDaysLine(b) {
+	if (b.added === 0 || b.days == null || b.perWeek == null) return null;
+	const work = `At the crew's pace (about ${b.perWeek} a week) that's about ${plural$5(b.days, "day")} of work`;
+	if (b.slip == null || b.slip <= 0) return `${work}.`;
+	if (b.days >= b.slip) return `${work}: enough to explain all ${plural$5(b.slip, "day")} of the slip.`;
+	return `${work}: about ${b.days} of the ${plural$5(b.slip, "day")} it has slipped.`;
+}
+/** One line for the brief or a list: "+14 tasks (38%) since the baseline, 3 this week, about 65 days of work". */
+function barnaclesShort(b) {
+	const pct = b.share != null ? ` (${Math.round(b.share * 100)}%)` : "";
+	const when = b.from === "baseline" ? "since the baseline" : "since its first week";
+	const week = b.thisWeek ? `, ${b.thisWeek} this week` : "";
+	const days = b.days != null ? `, about ${plural$5(b.days, "day")} of work` : "";
+	const top = b.adders.find((a) => a.personId);
+	const who = top && top.added * 2 > b.added ? `, mostly from ${top.name}` : "";
+	return `+${plural$5(b.added, "task")}${pct} ${when}${week}${days}${who}`;
+}
+/** Whether the brief names it: measured from a baseline, enough added, and enough of the plan. */
+function briefWorthy(b) {
+	return b.from === "baseline" && b.added >= 3 && (b.share == null || b.share >= .15);
+}
+var SETTLE_DAYS, BRIEF_MIN_ADDED, BRIEF_MIN_SHARE, noon$2, isoDay$3, plural$5;
+var init_barnacles = __esmMin((() => {
+	init_date_fns();
+	init_format();
+	init_tide();
+	SETTLE_DAYS = 7;
+	BRIEF_MIN_ADDED = 3;
+	BRIEF_MIN_SHARE = .15;
+	noon$2 = (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$5 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+}));
+
 //#endregion
 //#region src/lib/charter-lines.ts
 /** Nothing written on any of the five lines. */
@@ -2317,6 +3354,7 @@ var init_charter_lines = __esmMin((() => {
 //#endregion
 //#region src/lib/charter.ts
 init_indexes();
+init_barnacles();
 init_date_fns();
 init_date_text();
 init_premortem();
@@ -2493,6 +3531,7 @@ function voyageLog(data, projectId) {
 		fromBaseline: Boolean(project.baselineEnd),
 		tasks: tasks.length,
 		addedLate,
+		barnacles: barnaclesOf(project, tasks, data.people, /* @__PURE__ */ new Date(`${finished}T12:00:00`), Math.max(0, between(plannedEnd, finished)) || null),
 		slips,
 		risks,
 		issues: issues.length,
@@ -2540,6 +3579,13 @@ function voyageStory(log) {
 	const out = [];
 	const planned = `Planned ${md$2(log.plannedStart)} to ${md$2(log.plannedEnd)}`;
 	out.push(log.done ? `${planned}; finished ${md$2(log.finished)}.` : `${planned}; not Done yet.`);
+	const grew = barnaclesHeadline(log.barnacles);
+	if (grew) {
+		const who = log.barnacles.adders.filter((a) => a.personId);
+		const by = who.length ? ` (${who.map((a) => `${a.name} ${a.added}`).join(", ")})` : "";
+		const days = barnaclesDaysLine(log.barnacles);
+		out.push(`Barnacles: ${grew}${by}.${days ? ` ${days}` : ""}`);
+	}
 	for (const s of log.slips) {
 		const late = `“${s.task.title}” finished ${plural$4(s.daysLate, "day")} late`;
 		out.push(s.waitedOn ? `${late}; it waited on “${s.waitedOn.title}”, done ${md$2(s.waitedOn.completedAt)}.` : `${late}.`);
@@ -3549,416 +4595,80 @@ function cascadeDelete(data, kind, id) {
 			constraints,
 			raidItems,
 			comments: data.comments.filter((c) => !taskIds.has(c.taskId)),
-			attachments: (data.attachments ?? []).filter((a) => !taskIds.has(a.taskId)),
-			boardConfigs,
-			ropes: (data.ropes ?? []).map((r) => ({
-				...r,
-				taskIds: r.taskIds.filter((t) => !taskIds.has(t))
-			})),
-			spendEntries: (data.spendEntries ?? []).filter((e) => !projectIds.has(e.projectId)),
-			reflections: (data.reflections ?? []).filter((r) => !projectIds.has(r.projectId))
-		},
-		counts: {
-			programs: programIds.size,
-			projects: projectIds.size,
-			tasks: taskIds.size,
-			milestones: data.milestones.length - milestones.length,
-			raidItems: data.raidItems.length - raidItems.length,
-			constraints: (data.constraints ?? []).length - constraints.length
-		}
-	};
-}
-/** "2 projects, 14 tasks, 3 milestones and 2 risks or issues" — or "" when nothing else goes. */
-function cascadeSummary(counts, kind) {
-	const bits = [];
-	const n = (count, one, many) => count > 0 ? `${count} ${count === 1 ? one : many}` : null;
-	if (kind === "portfolio") bits.push(n(counts.programs, "program", "programs") ?? "");
-	if (kind !== "project") bits.push(n(counts.projects, "project", "projects") ?? "");
-	bits.push(n(counts.tasks, "task", "tasks") ?? "");
-	bits.push(n(counts.milestones, "milestone", "milestones") ?? "");
-	bits.push(n(counts.raidItems, "logged risk, issue or decision", "logged risks, issues and decisions") ?? "");
-	const list = bits.filter(Boolean);
-	if (list.length === 0) return "";
-	if (list.length === 1) return list[0];
-	return `${list.slice(0, -1).join(", ")} and ${list.at(-1)}`;
-}
-var init_cascade = __esmMin((() => {
-	init_blockers();
-}));
-
-//#endregion
-//#region src/lib/forecast.ts
-init_cascade();
-init_date_fns();
-const day$5 = (iso) => /* @__PURE__ */ new Date(`${iso}T12:00:00`);
-/**
-* A straight-line estimate at completion from the burn so far: spend divided
-* by the share of the schedule elapsed. Null before anything is spent or
-* before the schedule starts, since there is nothing to project yet. After
-* the end date the estimate is the spend itself.
-*/
-function forecastAtCompletion(item, now) {
-	if (item.spent <= 0) return null;
-	const total = differenceInCalendarDays(day$5(item.endDate), day$5(item.startDate)) + 1;
-	const gone = differenceInCalendarDays(now, day$5(item.startDate)) + 1;
-	if (total <= 0 || gone <= 0) return null;
-	const elapsed = Math.min(1, gone / total);
-	const eac = Math.round(item.spent / elapsed);
-	return {
-		eac,
-		variance: item.budget - eac,
-		elapsed,
-		tone: item.budget <= 0 ? "over" : eac > item.budget * 1.05 ? "over" : eac > item.budget * .95 ? "tight" : "under"
-	};
-}
-/** Sum of the children's estimates, using spend where a child has no forecast yet. */
-function forecastRollup(items, budget, now) {
-	const eac = items.map((i) => forecastAtCompletion(i, now)?.eac ?? i.spent).reduce((a, b) => a + b, 0);
-	if (eac <= 0) return null;
-	const elapsed = Math.max(0, ...items.map((i) => forecastAtCompletion(i, now)?.elapsed ?? 0));
-	return {
-		eac,
-		variance: budget - eac,
-		elapsed,
-		tone: budget <= 0 ? "over" : eac > budget * 1.05 ? "over" : eac > budget * .95 ? "tight" : "under"
-	};
-}
-
-//#endregion
-//#region src/lib/soundings.ts
-/** Why a number can't be an answer, or null when it can: half days up to SOUNDING_MAX_DAYS. */
-function daysProblem(days) {
-	if (!Number.isFinite(days) || days <= 0) return "Give a number of days above 0, like 3 or 0.5.";
-	if (days > 250) return `Keep it to ${250} working days or fewer.`;
-	if (Math.round(days * 2) !== days * 2) return "Use whole or half days, like 3 or 2.5.";
-	return null;
-}
-/** Each asked person's latest answer to the task's current sounding, oldest first. */
-function answersFor(reflections, task) {
-	const s = task.sounding;
-	if (!s) return [];
-	const crew = new Set(s.crewIds);
-	const latest = /* @__PURE__ */ new Map();
-	for (const r of reflections ?? []) {
-		if (r.kind !== "sounding" || r.taskId !== task.id || typeof r.days !== "number") continue;
-		if (r.createdAt < s.askedAt || !crew.has(r.authorId)) continue;
-		const had = latest.get(r.authorId);
-		if (!had || r.createdAt >= had.createdAt) latest.set(r.authorId, r);
-	}
-	return [...latest.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-}
-/** Middle of the guesses, to the half day. */
-function middleOf(days) {
-	if (days.length === 0) return null;
-	const sorted = [...days].sort((a, b) => a - b);
-	const mid = Math.floor(sorted.length / 2);
-	const m = sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
-	return Math.round(m * 2) / 2;
-}
-/**
-* Guesses far enough apart to talk about first: the highest at least twice
-* the lowest and three or more days from it. 3 against 5 is agreement; 2
-* against 15, or 5 against 10, is two people seeing different work.
-*/
-function isWide(days) {
-	if (days.length < 2) return false;
-	const low = Math.min(...days);
-	const high = Math.max(...days);
-	return high - low >= 3 && high >= low * 2;
-}
-/** Where a task's sounding stands, or null when nobody asked. */
-function readSounding(task, reflections, now) {
-	const s = task.sounding;
-	if (!s) return null;
-	const answers = answersFor(reflections, task);
-	const by = new Set(answers.map((a) => a.authorId));
-	const waitingOn = s.crewIds.filter((id) => !by.has(id));
-	const early = Boolean(s.shownAt && Date.parse(s.shownAt) <= now.getTime());
-	const shown = answers.length > 0 && (waitingOn.length === 0 || early);
-	const days = answers.map((a) => a.days);
-	const wide = shown && isWide(days);
-	const middle = middleOf(days);
-	const settled = s.settledDays ?? null;
-	return {
-		sounding: s,
-		crewIds: s.crewIds,
-		answers,
-		waitingOn,
-		shown,
-		low: days.length ? Math.min(...days) : null,
-		high: days.length ? Math.max(...days) : null,
-		middle,
-		wide,
-		estimate: settled ?? (shown && !wide ? middle : null)
-	};
-}
-/** What one person may see: their own answer always; everyone's once shown. */
-function visibleAnswers(read, personId) {
-	return read.shown ? read.answers : read.answers.filter((a) => a.authorId === personId);
-}
-/**
-* The answers the forecast draws from for an open task: the settled number
-* alone once there is one, otherwise every answer in so far (the spread is
-* the point, and the forecast names nobody's guess).
-*/
-function soundingDraws(task, reflections) {
-	const s = task.sounding;
-	if (!s) return [];
-	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) {
-	let left = Math.ceil(days);
-	let d = 0;
-	while (left > 0) {
-		d += 1;
-		const wd = addDays(from, d).getDay();
-		if (wd !== 0 && wd !== 6) left -= 1;
-	}
-	return d;
-}
-/** "half a day", "1 day", "2.5 days". */
-function daysText(days) {
-	if (days === .5) return "half a day";
-	return `${days} day${days === 1 ? "" : "s"}`;
-}
-/**
-* Who a new sounding asks unless you pick: you, the task's owner, and the
-* people with open work on its project, agents left out.
-*/
-function suggestedCrew(data, task, meId) {
-	const people = new Map(data.people.filter((p) => p.kind !== "agent").map((p) => [p.id, p]));
-	const out = /* @__PURE__ */ new Set();
-	if (people.has(meId)) out.add(meId);
-	if (task.assigneeId && people.has(task.assigneeId)) out.add(task.assigneeId);
-	for (const t of data.tasks) {
-		if (out.size >= 6) break;
-		if (t.projectId !== task.projectId || t.status === "done" || !t.assigneeId) continue;
-		if (people.has(t.assigneeId)) out.add(t.assigneeId);
-	}
-	return [...out];
-}
-/** "Close enough: about 4 days", or why it needs talking through. */
-function soundingVerdict(read) {
-	if (read.sounding.settledDays != null) return `Settled on ${daysText(read.sounding.settledDays)}.`;
-	if (read.wide) return `Talk about this first: guesses run from ${daysText(read.low)} to ${daysText(read.high)}, so someone sees work the others don't.`;
-	return `Close enough: about ${daysText(read.estimate)}.`;
-}
-/** Open tasks whose sounding waits on this person's answer. */
-function soundingsWaitingOn(data, personId, now) {
-	return data.tasks.filter((t) => {
-		if (t.status === "done" || !t.sounding?.crewIds.includes(personId)) return false;
-		return readSounding(t, data.reflections, now).waitingOn.includes(personId);
-	});
-}
-var SOUNDING_MAX_DAYS;
-var init_soundings = __esmMin((() => {
-	init_date_fns();
-	SOUNDING_MAX_DAYS = 250;
-}));
-
-//#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
-* weeks by drawing at random from the project's recent weekly counts, until
-* the open tasks run out; the spread of finish days is the forecast. No
-* estimates or story points: only tasks and when they were finished.
-*
-* Seeded from the project and the day, so the same project reads the same
-* on the server and the client and doesn't jitter between renders.
-*/
-/** How many weeks back the crew's pace is read from. */
-const TIDE_WEEKS = 6;
-const TRIALS = 1e3;
-/** A run that hasn't finished in two years is counted as not finishing. */
-const MAX_WEEKS = 104;
-/** Fewer finished tasks than this and the forecast says it's rough. */
-const ROUGH_BELOW = 5;
-const noon$2 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
-/** 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$2(todayISO(now));
-	const age = Math.floor(differenceInCalendarDays(today, noon$2(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$2(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;
-	}
-	return counts;
-}
-function hash(text) {
-	let h = 2166136261;
-	for (let i = 0; i < text.length; i++) {
-		h ^= text.charCodeAt(i);
-		h = Math.imul(h, 16777619);
-	}
-	return h >>> 0;
-}
-/** mulberry32: small, fast, and the same everywhere for the same seed. */
-function random(seed) {
-	let a = seed;
-	return () => {
-		a = a + 1831565813 | 0;
-		let t = Math.imul(a ^ a >>> 15, 1 | a);
-		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+			attachments: (data.attachments ?? []).filter((a) => !taskIds.has(a.taskId)),
+			boardConfigs,
+			ropes: (data.ropes ?? []).map((r) => ({
+				...r,
+				taskIds: r.taskIds.filter((t) => !taskIds.has(t))
+			})),
+			spendEntries: (data.spendEntries ?? []).filter((e) => !projectIds.has(e.projectId)),
+			reflections: (data.reflections ?? []).filter((r) => !projectIds.has(r.projectId))
+		},
+		counts: {
+			programs: programIds.size,
+			projects: projectIds.size,
+			tasks: taskIds.size,
+			milestones: data.milestones.length - milestones.length,
+			raidItems: data.raidItems.length - raidItems.length,
+			constraints: (data.constraints ?? []).length - constraints.length
+		}
 	};
 }
-/** Days from today to finishing, one per run; Infinity for a run that never does. */
-function simulate(remaining, weekly, seed, pace = 1) {
-	const next = random(seed);
-	const out = [];
-	for (let run = 0; run < TRIALS; run++) {
-		let left = remaining;
-		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);
-			if (closed >= left) {
-				const landed = Array.from({ length: closed }, () => 1 + Math.floor(next() * 7));
-				landed.sort((a, b) => a - b);
-				days = week * 7 + landed[left - 1];
-				break;
-			}
-			left -= closed;
-		}
-		out.push(days);
-	}
-	return out.sort((a, b) => a - b);
+/** "2 projects, 14 tasks, 3 milestones and 2 risks or issues" — or "" when nothing else goes. */
+function cascadeSummary(counts, kind) {
+	const bits = [];
+	const n = (count, one, many) => count > 0 ? `${count} ${count === 1 ? one : many}` : null;
+	if (kind === "portfolio") bits.push(n(counts.programs, "program", "programs") ?? "");
+	if (kind !== "project") bits.push(n(counts.projects, "project", "projects") ?? "");
+	bits.push(n(counts.tasks, "task", "tasks") ?? "");
+	bits.push(n(counts.milestones, "milestone", "milestones") ?? "");
+	bits.push(n(counts.raidItems, "logged risk, issue or decision", "logged risks, issues and decisions") ?? "");
+	const list = bits.filter(Boolean);
+	if (list.length === 0) return "";
+	if (list.length === 1) return list[0];
+	return `${list.slice(0, -1).join(", ")} and ${list.at(-1)}`;
 }
+var init_cascade = __esmMin((() => {
+	init_blockers();
+}));
+
+//#endregion
+//#region src/lib/forecast.ts
+init_cascade();
+init_date_fns();
+const day$5 = (iso) => /* @__PURE__ */ new Date(`${iso}T12:00:00`);
 /**
-* Per run, the fewest days the sounded tasks allow: each draws one of its
-* answers at random, so a wide spread widens the forecast. A task already
-* in play counts half its days; it's partly done.
+* A straight-line estimate at completion from the burn so far: spend divided
+* by the share of the schedule elapsed. Null before anything is spent or
+* before the schedule starts, since there is nothing to project yet. After
+* the end date the estimate is the spend itself.
 */
-function soundingFloors(tasks, reflections, base, seed) {
-	const draws = [];
-	for (const t of tasks) {
-		if (t.status === "done") continue;
-		const days = soundingDraws(t, reflections);
-		if (days.length === 0) continue;
-		draws.push({
-			days,
-			share: t.status === "doing" || t.status === "review" ? .5 : 1
-		});
-	}
-	if (draws.length === 0) return {
-		floors: null,
-		sounded: 0
-	};
-	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));
-		return v;
-	};
-	const floors = [];
-	for (let run = 0; run < TRIALS; run++) {
-		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));
-		}
-		floors.push(most);
-	}
+function forecastAtCompletion(item, now) {
+	if (item.spent <= 0) return null;
+	const total = differenceInCalendarDays(day$5(item.endDate), day$5(item.startDate)) + 1;
+	const gone = differenceInCalendarDays(now, day$5(item.startDate)) + 1;
+	if (total <= 0 || gone <= 0) return null;
+	const elapsed = Math.min(1, gone / total);
+	const eac = Math.round(item.spent / elapsed);
 	return {
-		floors,
-		sounded: draws.length
+		eac,
+		variance: item.budget - eac,
+		elapsed,
+		tone: item.budget <= 0 ? "over" : eac > item.budget * 1.05 ? "over" : eac > item.budget * .95 ? "tight" : "under"
 	};
 }
-/**
-* `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).
-*/
-function tideForecast(project, tasks, now, opts = {}) {
-	const remaining = tasks.filter((t) => t.status !== "done").length;
-	if (remaining === 0) return { kind: "done" };
-	if (project.health === "paused") return {
-		kind: "paused",
-		remaining
-	};
-	const weekly = weeklyFinished(tasks, project.startDate, now);
-	const finished = weekly.reduce((a, b) => a + b, 0);
-	if (finished === 0) return {
-		kind: "no-pace",
-		remaining
-	};
-	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 at = (share, list = runs) => list[Math.min(list.length - 1, Math.ceil(share * list.length) - 1)];
-	let lastDue = null;
-	for (const t of tasks) {
-		if (t.status === "done" || !t.dueDate) continue;
-		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 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$2(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 = [];
-	const step = Math.max(1, Math.ceil(last / 60));
-	let i = 0;
-	for (let d = 0; d <= last; d += step) {
-		while (i < runs.length && runs[i] <= d) i++;
-		curve.push({
-			date: dayOf(d),
-			chance: i / runs.length
-		});
-	}
+/** Sum of the children's estimates, using spend where a child has no forecast yet. */
+function forecastRollup(items, budget, now) {
+	const eac = items.map((i) => forecastAtCompletion(i, now)?.eac ?? i.spent).reduce((a, b) => a + b, 0);
+	if (eac <= 0) return null;
+	const elapsed = Math.max(0, ...items.map((i) => forecastAtCompletion(i, now)?.elapsed ?? 0));
 	return {
-		kind: "forecast",
-		remaining,
-		finished,
-		weeks: weekly.length,
-		perWeek: Math.round(finished / weekly.length * Math.max(0, opts.pace ?? 1) * 10) / 10,
-		likely: dayOf(at(.5)),
-		veryLikely: dayOf(at(.85)),
-		almostCertain: dayOf(at(.95)),
-		chanceByEnd: Math.round(byEnd * 100) / 100,
-		curve,
-		rough: finished < ROUGH_BELOW,
-		heldBy,
-		sounded: sounded.sounded
+		eac,
+		variance: budget - eac,
+		elapsed,
+		tone: budget <= 0 ? "over" : eac > budget * 1.05 ? "over" : eac > budget * .95 ? "tight" : "under"
 	};
 }
-/** "15%", with "under 5%" and "over 95%" at the ends, where a thousand runs can't be that sure. */
-function chanceText(chance) {
-	if (chance < .05) return "under 5%";
-	if (chance > .95) return "over 95%";
-	return `${Math.round(chance * 20) * 5}%`;
-}
-/**
-* The open task whose due date sets the finish, when the crew's pace alone
-* would be done sooner; null otherwise.
-*/
-function dueAfterFinish(tide) {
-	return tide.kind === "forecast" ? tide.heldBy : null;
-}
-/** Why there's no forecast, for the states without one. */
-function tideQuiet(tide) {
-	switch (tide.kind) {
-		case "done": return "Every task is done.";
-		case "paused": return "Paused, so its pace says nothing about when it ends.";
-		case "no-pace": return `Nothing finished in the last ${6} weeks, so there's no pace to forecast from yet.`;
-		default: return null;
-	}
-}
 
 //#endregion
 //#region src/lib/flow.ts
@@ -4205,12 +4915,17 @@ function slipDays(p) {
 	if (!p.baselineEnd) return null;
 	return differenceInCalendarDays(day$3(p.endDate), day$3(p.baselineEnd));
 }
-/** The projects with the current dates committed as their baseline; ones that already have one are left alone unless `reset`. */
-function withBaseline(projects, reset = false) {
+/**
+* The projects with the current dates committed as their baseline; ones that
+* already have one are left alone unless `reset`. `at` is when (ISO), so work
+* added later reads as growth.
+*/
+function withBaseline(projects, reset = false, at) {
 	return projects.map((p) => hasBaseline(p) && !reset ? p : {
 		...p,
 		baselineStart: p.startDate,
-		baselineEnd: p.endDate
+		baselineEnd: p.endDate,
+		...at ? { baselineAt: at } : {}
 	});
 }
 /** A caption for the timeline: "slipped 12 days", "12 days early", or null when on the baseline. */
@@ -4620,6 +5335,7 @@ init_date_fns();
 init_format();
 init_indexes();
 init_spend();
+init_tide();
 /**
 * The cost of a slip: what each week past a project's end date costs, from
 * how fast its spend ledger has been burning, set against the tide forecast's
@@ -4689,9 +5405,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;
@@ -4744,6 +5461,7 @@ var init_work = __esmMin((() => {
 init_date_fns();
 init_date_text();
 init_indexes();
+init_tide();
 init_format();
 init_raid();
 init_spend();
@@ -4966,7 +5684,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 +6091,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);
@@ -6318,6 +7036,16 @@ var init_decisions = __esmMin((() => {
 
 //#endregion
 //#region src/lib/brief.ts
+/**
+* Open projects whose plan has grown enough since the baseline to mention
+* (barnacles.ts), most grown first.
+*/
+function barnacleLinesOf(data, projects, now) {
+	return projects.filter((p) => p.health !== "done").map((project) => ({
+		project,
+		barnacles: barnaclesOf(project, tasksOf(data.tasks, project.id), data.people, now, Math.max(0, slipDays(project) ?? 0) || null)
+	})).filter((l) => briefWorthy(l.barnacles)).sort((a, b) => (b.barnacles.share ?? 0) - (a.barnacles.share ?? 0)).slice(0, 5);
+}
 /** Late tasks worst first, each with what it holds up, so the letter says what to chase. */
 function lateLinesOf(data, tasks, now) {
 	const waiters = waitersByBlocker(tasks);
@@ -6425,6 +7153,11 @@ function composeBriefBody(opts) {
 		for (const d of opts.revisit) lines.push(`• ${d.title}${d.where ? ` (${d.where})` : ""}: ${d.reason}`);
 		lines.push("");
 	}
+	if (opts.barnacles?.length) {
+		lines.push("Barnacles (work added since the baseline)");
+		for (const b of opts.barnacles) lines.push(`• ${b.project}: ${b.line}`);
+		lines.push("");
+	}
 	const done = () => {
 		if (!opts.shipped?.length) return;
 		lines.push("Done this week");
@@ -6674,6 +7407,7 @@ function briefOf(data, opts = {}) {
 			projectIds,
 			portfolioId
 		}), todayISO(now)),
+		barnacles: barnacleLinesOf(data, projects, now),
 		talk,
 		milestonesSoon,
 		milestonesLate,
@@ -6730,6 +7464,10 @@ function composeBriefBodyFrom(brief, data, workspace, all = false) {
 			title: d.item.title,
 			reason: d.reason,
 			where: d.where
+		})),
+		barnacles: brief.barnacles.map((b) => ({
+			project: b.project.name,
+			line: barnaclesShort(b.barnacles)
 		}))
 	});
 }
@@ -6741,7 +7479,7 @@ function briefHidden(brief) {
 	const over = (n) => Math.max(0, n - 8);
 	return over(brief.late.length) + over(brief.finished.length);
 }
-var BRIEF_QUIET, BRIEF_LATE_SHOWN;
+var BRIEF_BARNACLES_SHOWN, BRIEF_QUIET, BRIEF_LATE_SHOWN;
 var init_brief = __esmMin((() => {
 	init_date_fns();
 	init_date_text();
@@ -6755,6 +7493,9 @@ var init_brief = __esmMin((() => {
 	init_clock();
 	init_bottle();
 	init_decisions();
+	init_barnacles();
+	init_baseline();
+	BRIEF_BARNACLES_SHOWN = 5;
 	BRIEF_QUIET = "Nothing late or at risk. Say what shipped — or enjoy the quiet week.";
 	BRIEF_LATE_SHOWN = 8;
 }));
@@ -8843,14 +9584,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) {
@@ -11989,6 +12744,7 @@ init_format();
 init_indexes();
 init_load();
 init_task_keys();
+init_tide();
 const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
 const MAX_ADD = 200;
 /**
@@ -17647,7 +18403,8 @@ function chainOf(line, walk, target, today) {
 		links,
 		finish,
 		target,
-		over: target ? days$1(target, finish) : null
+		over: target ? days$1(target, finish) : null,
+		undated: 0
 	};
 }
 /** What sets a project's date: the line behind its open task that finishes last. */
@@ -17672,7 +18429,11 @@ function projectPole(project, all, now) {
 		kind: "none",
 		reason: "None of its open tasks has a due date, so there's no date to trace."
 	};
-	return chainOf(lineTo(last, all, walk), walk, project.endDate.slice(0, 10), today);
+	const undated = mine.filter((t) => !walk(t).finish).length;
+	return {
+		...chainOf(lineTo(last, all, walk), walk, project.endDate.slice(0, 10), today),
+		undated
+	};
 }
 /** What holds one task up: the line of open tasks it waits on, ending at it. */
 function taskPole(task, all, now) {
@@ -17738,7 +18499,8 @@ function milestonePole(milestone, data, now) {
 			project: first.project,
 			finish: first.finish
 		},
-		others
+		others,
+		undated: first.pole.kind === "chain" ? first.pole.undated : 0
 	};
 }
 const plural$2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
@@ -17763,6 +18525,12 @@ function poleHeadline(pole, name, held) {
 	if (pole.over === 0) return `${lead}, right on ${held}.${tail}`;
 	return `${lead}, ${plural$2(-pole.over, "day")} before ${held}.${tail}`;
 }
+/** "13 open tasks have no due date, so they can't hold the date."; null when none. */
+function undatedText(pole) {
+	if (pole.kind !== "chain" || pole.undated === 0) return null;
+	const n = pole.undated;
+	return n === 1 ? "1 open task has no due date, so it can't hold the date." : `${n} open tasks have no due date, so they can't hold the date.`;
+}
 
 //#endregion
 //#region src/lib/csv.ts
@@ -18156,6 +18924,8 @@ var init_passage = __esmMin((() => {
 init_task_keys();
 init_brief();
 init_indexes();
+init_tide();
+init_barnacles();
 init_spend();
 init_hill();
 init_raid();
@@ -18173,6 +18943,7 @@ init_work();
 init_fog();
 init_passage();
 init_board();
+init_holidays();
 init_soundings();
 /**
 * Where the website opens one task or project, switching to its harbor
@@ -18195,6 +18966,30 @@ function publicRoadmap(ctx, projectId) {
 		...ctx.origin ? { url: `${ctx.origin}/roadmap/${token}` } : {}
 	};
 }
+/** A project's scope growth (src/lib/barnacles.ts), for an agent: numbers and the sentences the website shows. */
+function barnaclesData(b) {
+	return {
+		measuredFrom: b.from === "baseline" ? "when the baseline was set" : "a week after its first task was made",
+		since: b.since,
+		planned: b.planned,
+		added: b.added,
+		addedPercent: b.share == null ? null : Math.round(b.share * 100),
+		addedThisWeek: b.thisWeek,
+		headline: barnaclesHeadline(b),
+		tasksPerWeek: b.perWeek,
+		daysOfWork: b.days,
+		slipDays: b.slip,
+		daysLine: barnaclesDaysLine(b),
+		byWeek: b.weeks.filter((w) => w.added > 0).map((w) => ({
+			weekOf: w.week,
+			added: w.added
+		})),
+		byWho: b.adders.map((a) => ({
+			who: a.personId ? a.name : null,
+			added: a.added
+		}))
+	};
+}
 /** A question the tool can't answer as asked; the agent sees the message. */
 var ToolError = class extends Error {};
 /**
@@ -18225,8 +19020,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 +19048,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 +19487,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 +19558,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),
@@ -18943,7 +19746,7 @@ const HARBOR_TOOLS = [
 	tool({
 		name: "weekly_brief",
 		title: "Weekly brief",
-		description: "The weekly brief as the website writes it: programs off track and at risk, risks and issues to watch, milestones, late work and what it holds up, what got done this week and what the crew said. Plain text, ready to send." + DATA_NOTE,
+		description: "The weekly brief as the website writes it: programs off track and at risk, risks and issues to watch, milestones, late work and what it holds up, projects whose plan grew a lot since the baseline (barnacles), what got done this week and what the crew said. Plain text, ready to send." + DATA_NOTE,
 		input: object({
 			harbor: harborArg,
 			portfolio: string().max(200).optional().describe("Portfolio id or name; all when left out."),
@@ -19217,6 +20020,7 @@ const HARBOR_TOOLS = [
 					...d.rationale?.trim() ? { why: d.rationale.trim() } : {},
 					...d.status === "superseded" ? { changedLater: true } : {}
 				})),
+				barnacles: barnaclesData(log.barnacles),
 				closedBy: log.carriers.map((c) => ({
 					who: c.person.name,
 					tasks: c.closed
@@ -19258,10 +20062,44 @@ 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$1(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",
-		description: "The long pole behind a project, a task or a milestone: of all the task waits behind it, the one line that sets its date, first blocker to last. Each link has its due date, the soonest it can finish (its due date, later when what it waits on finishes after, today at the earliest for late work) and slack: days it can slip before it moves the next link, or the end; negative when it already does. over is how many days the line finishes past the date held (a project's end, a task's or milestone's due date). For a milestone, via is the project it waits on that finishes last, and others are the rest with their slack." + DATA_NOTE,
+		description: "The long pole behind a project, a task or a milestone: of all the task waits behind it, the one line that sets its date, first blocker to last. Each link has its due date, the soonest it can finish (its due date, later when what it waits on finishes after, today at the earliest for late work) and slack: days it can slip before it moves the next link, or the end; negative when it already does. daysSpare is how many days the line finishes before the date held (endDate for a project, dueDate for a task or milestone); negative is that many days over. undated counts open tasks left out for having no due date (note says so). For a milestone, via is the project it waits on that finishes last, and others are the rest with their slack." + DATA_NOTE,
 		input: object({
 			harbor: harborArg,
 			of: string().min(1).max(200).describe("A project (id, name or key like \"RR\"), a task key (\"RR-42\") or a milestone (id or name).")
@@ -19287,8 +20125,10 @@ const HARBOR_TOOLS = [
 					},
 					headline: poleHeadline(pole, name, held),
 					finish: pole.finish,
-					held: pole.target,
-					over: pole.over,
+					[kind === "project" ? "endDate" : "dueDate"]: pole.target,
+					daysSpare: pole.over == null ? null : -pole.over,
+					undated: pole.undated,
+					...undatedText(pole) ? { note: undatedText(pole) } : {},
 					...pole.via ? { via: {
 						project: pole.via.project.name,
 						finish: pole.via.finish
@@ -19324,7 +20164,12 @@ const HARBOR_TOOLS = [
 				try {
 					milestone = findOne(milestones.length ? milestones : data.milestones, input.of, "milestone");
 				} catch (inner) {
-					if (inner instanceof ToolError && /^No milestone matches/.test(inner.message)) throw new ToolError(`No project, task key or open milestone matches "${input.of.trim()}".`);
+					if (inner instanceof ToolError && /^No milestone matches/.test(inner.message)) {
+						const projects = data.projects.filter((x) => x.health !== "done");
+						const there = [...projects.slice(0, 12).map((x) => x.key ? `${x.name} (${x.key})` : x.name), ...projects.length > 12 ? [`and ${projects.length - 12} more`] : []];
+						const marks = milestones.slice(0, 6).map((m) => m.name);
+						throw new ToolError(`No project, task key or open milestone matches "${input.of.trim()}".` + (there.length ? ` Open projects: ${there.join(", ")}.` : "") + (marks.length ? ` Open milestones: ${marks.join(", ")}.` : ""));
+					}
 					throw inner;
 				}
 				return answer("milestone", milestone.name, milestonePole(milestone, data, ctx.now), "the milestone");
@@ -19332,6 +20177,26 @@ const HARBOR_TOOLS = [
 			return answer("project", project.name, projectPole(project, data.tasks, ctx.now), "the end date");
 		}
 	}),
+	tool({
+		name: "scope_growth",
+		title: "Barnacles: work added since the plan was set",
+		description: "How much a project's plan has grown since it was set (barnacles): tasks made after the baseline was set (or, without a baseline time, after the project's first week of tasks), as a count and a percent of what was planned, by week (weekOf is a Monday) and by who added them (who is null for tasks made before Harbor kept track, or by a form). daysOfWork puts them at the crew's pace (tasks finished a week over the last six); slipDays is how late the project runs against its planned end (the likely finish at that pace, or the end date's move from the baseline), and daysLine says how much of it the added work explains." + DATA_NOTE,
+		input: object({
+			harbor: harborArg,
+			project: string().min(1).max(200).describe("Project id, name or key.")
+		}),
+		run: (ctx, input) => {
+			const { data } = ctx;
+			const p = findOne(data.projects, input.project, "project");
+			const tasks = tasksOf(data.tasks, p.id);
+			const b = barnaclesOf(p, tasks, data.people, ctx.now, slipAgainstPlan(p, tasks, ctx.now));
+			return {
+				project: p.name,
+				...p.key ? { key: p.key } : {},
+				...barnaclesData(b)
+			};
+		}
+	}),
 	tool({
 		name: "shipping_forecast",
 		title: "The harbor forecast",
@@ -19566,7 +20431,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. */
@@ -20622,7 +21488,7 @@ function hierarchySlice({ get, write }) {
 		},
 		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);
+			const stamped = withBaseline(get().projects.filter((p) => inProgram.has(p.id)), reset, stamp());
 			const byId = new Map(stamped.map((p) => [p.id, p]));
 			write({ projects: get().projects.map((p) => byId.get(p.id) ?? p) });
 			const program = get().programs.find((p) => p.id === programId);
@@ -20972,6 +21838,7 @@ function tasksSlice({ set, get, write }) {
 				...t,
 				id,
 				createdAt: stamp(),
+				createdById: get().currentUserId || null,
 				completedAt: t.status === "done" ? t.completedAt ?? stamp() : null,
 				checklist: t.checklist ?? [],
 				...blockersPatch(blockerIds({
@@ -21845,6 +22712,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 +22908,7 @@ var init_people_spend = __esmMin((() => {
 	init_assignment();
 	init_spend();
 	init_utils();
+	init_countries();
 	init_shared();
 	init_allocation();
 }));
@@ -22153,7 +23034,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 +23118,8 @@ var init_changes = __esmMin((() => {
 		"checkIns",
 		"spendEntries",
 		"reflections",
-		"priorityRules"
+		"priorityRules",
+		"workCalendar"
 	];
 	ROW_COLLECTIONS = [
 		"tasks",
@@ -22257,7 +23139,8 @@ var init_changes = __esmMin((() => {
 		"boardConfigs",
 		"ropes",
 		"readPingIds",
-		"priorityRules"
+		"priorityRules",
+		"workCalendar"
 	];
 	KEYED = {
 		boardConfigs: {
@@ -22288,6 +23171,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;
@@ -24149,6 +25043,7 @@ var init_repo_sync = __esmMin((() => {
 //#region src/tui/try.ts
 init_format();
 init_task_keys();
+init_tide();
 init_view_only();
 init_errors();
 init_repo_sync();