@harborppm/cli 0.95.0 → 0.97.0

package/dist/app.mjs

@@ -2688,13 +2688,13 @@ var init_holidays = __esmMin((() => {
 // src/lib/tide.ts
 /** Tasks finished in each of the last weeks, oldest first. Done tasks without a date, or dated after now, count as finished now. */
 function weeklyFinished(tasks, startDate, now, weeks = 6) {
-	const today = noon$3(todayISO(now));
-	const age = Math.floor(differenceInCalendarDays(today, noon$3(startDate)) / 7) + 1;
+	const today = noon$4(todayISO(now));
+	const age = Math.floor(differenceInCalendarDays(today, noon$4(startDate)) / 7) + 1;
 	const span = Math.max(1, Math.min(weeks, age));
 	const counts = new Array(span).fill(0);
 	for (const t of tasks) {
 		if (t.status !== "done") continue;
-		const at = t.completedAt ? noon$3(t.completedAt) : today;
+		const at = t.completedAt ? noon$4(t.completedAt) : today;
 		const back = Math.max(0, differenceInCalendarDays(today, at));
 		const week = Math.floor(back / 7);
 		if (week < span) counts[span - 1 - week] += 1;
@@ -2872,7 +2872,7 @@ function tideOptions(data) {
 function tideForecast(project, tasks, now, opts = {}) {
 	if (tasks.length === 0) return { kind: "empty" };
 	const remaining = tasks.filter((t) => t.status !== "done").length;
-	if (remaining === 0) return { kind: "done" };
+	if (remaining === 0 || project.health === "done") return { kind: "done" };
 	if (project.health === "paused") return {
 		kind: "paused",
 		remaining
@@ -2885,7 +2885,7 @@ function tideForecast(project, tasks, now, opts = {}) {
 		finished
 	};
 	const today = todayISO(now);
-	const base = noon$3(today);
+	const base = noon$4(today);
 	const { shares, crew } = weekShares(tasks, base, opts.calendar);
 	const paced = simulate(remaining, weekly, hash(`${project.id}|${remaining}|${today}`), Math.max(0, opts.pace ?? 1), shares);
 	const at = (share, list = runs) => list[Math.min(list.length - 1, Math.ceil(share * list.length) - 1)];
@@ -2894,12 +2894,12 @@ function tideForecast(project, tasks, now, opts = {}) {
 		if (t.status === "done" || !t.dueDate) continue;
 		if (!lastDue || t.dueDate > lastDue.dueDate) lastDue = t;
 	}
-	const floor = lastDue ? differenceInCalendarDays(noon$3(lastDue.dueDate), base) : 0;
+	const floor = lastDue ? differenceInCalendarDays(noon$4(lastDue.dueDate), base) : 0;
 	const sounded = soundingFloors(tasks, opts.reflections, base, hash(`${project.id}|sound|${today}`), opts.calendar);
 	const runs = paced.map((d, i) => Math.max(d, floor, sounded.floors?.[i] ?? 0)).sort((a, b) => a - b);
 	const heldBy = lastDue && floor > at(.5, paced) ? lastDue : null;
 	const dayOf = (days) => Number.isFinite(days) ? todayISO(addDays(base, days)) : null;
-	const toEnd = differenceInCalendarDays(noon$3(project.endDate), base);
+	const toEnd = differenceInCalendarDays(noon$4(project.endDate), base);
 	const byEnd = runs.filter((d) => d <= toEnd).length / runs.length;
 	const last = Math.max(Number.isFinite(at(.99)) ? at(.99) : 728, toEnd + 14, 7);
 	const curve = [];
@@ -2952,7 +2952,7 @@ function tideQuiet(tide) {
 		default: return null;
 	}
 }
-var TIDE_WEEKS, TRIALS, MAX_WEEKS, ROUGH_BELOW, TIDE_MIN_FINISHED, noon$3;
+var TIDE_WEEKS, TRIALS, MAX_WEEKS, ROUGH_BELOW, TIDE_MIN_FINISHED, noon$4;
 var init_tide = __esmMin((() => {
 	init_date_fns();
 	init_format();
@@ -2963,7 +2963,7 @@ var init_tide = __esmMin((() => {
 	MAX_WEEKS = 104;
 	ROUGH_BELOW = 5;
 	TIDE_MIN_FINISHED = 3;
-	noon$3 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+	noon$4 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
 }));
 
 // src/lib/barnacles.ts
@@ -2980,7 +2980,7 @@ function planSetAt(project, tasks) {
 	for (const t of tasks) if (!first || t.createdAt < first) first = t.createdAt;
 	first = (first ?? project.startDate).slice(0, 10);
 	return {
-		since: `${isoDay$3(addDays(noon$2(first), 7))}T00:00:00`,
+		since: `${isoDay$3(addDays(noon$3(first), 7))}T00:00:00`,
 		from: "start"
 	};
 }
@@ -2992,20 +2992,20 @@ function planSetAt(project, tasks) {
 function barnaclesOf(project, tasks, people, now, slip = null) {
 	const { since, from } = planSetAt(project, tasks);
 	const today = todayISO(now);
-	const weekAgo = isoDay$3(addDays(noon$2(today), -7));
+	const weekAgo = isoDay$3(addDays(noon$3(today), -7));
 	let planned = 0;
 	const added = [];
 	for (const t of tasks) if (t.createdAt > since) added.push(t);
 	else planned += 1;
-	const first = startOfWeek(noon$2(since), { weekStartsOn: 1 });
-	const span = Math.max(0, Math.floor(differenceInCalendarDays(noon$2(today), first) / 7));
+	const first = startOfWeek(noon$3(since), { weekStartsOn: 1 });
+	const span = Math.max(0, Math.floor(differenceInCalendarDays(noon$3(today), first) / 7));
 	const weeks = Array.from({ length: Math.min(span + 1, 104) }, (_, i) => ({
 		week: isoDay$3(addDays(first, i * 7)),
 		added: 0
 	}));
 	const counts = /* @__PURE__ */ new Map();
 	for (const t of added) {
-		const i = Math.floor(differenceInCalendarDays(noon$2(t.createdAt), first) / 7);
+		const i = Math.floor(differenceInCalendarDays(noon$3(t.createdAt), first) / 7);
 		const slot = weeks[Math.min(Math.max(0, i), weeks.length - 1)];
 		if (slot) slot.added += 1;
 		const who = t.createdById ?? null;
@@ -3023,7 +3023,7 @@ function barnaclesOf(project, tasks, people, now, slip = null) {
 	const byDay = /* @__PURE__ */ new Map();
 	for (const t of added) byDay.set(t.createdAt.slice(0, 10), (byDay.get(t.createdAt.slice(0, 10)) ?? 0) + 1);
 	const [bulkDay, bulk] = [...byDay].sort((a, b) => b[1] - a[1])[0] ?? [null, 0];
-	const age = differenceInCalendarDays(noon$2(today), addDays(noon$2(since), -7)) / 7;
+	const age = differenceInCalendarDays(noon$3(today), addDays(noon$3(since), -7)) / 7;
 	let caveat = null;
 	if (added.length && bulkDay && bulk >= 5 && bulk >= added.length * .5) caveat = `${bulk} of the ${added.length} came in on ${shortDate(bulkDay)}, which looks like the plan being loaded rather than growth, so treat this as rough. Setting a baseline counts from then on.`;
 	else if (added.length && from === "start" && (planned < 5 || age < 3)) caveat = "There's no baseline yet and the plan is young, so its first weeks may be the plan being written: treat this as rough. Setting a baseline counts from then on.";
@@ -3050,8 +3050,8 @@ function barnaclesOf(project, tasks, people, now, slip = null) {
 */
 function slipAgainstPlan(project, tasks, now, tide = tideForecast(project, tasks, now)) {
 	const plannedEnd = (project.baselineEnd ?? project.endDate).slice(0, 10);
-	const likely = tide.kind === "forecast" && tide.likely ? differenceInCalendarDays(noon$2(tide.likely), noon$2(plannedEnd)) : 0;
-	const moved = project.baselineEnd ? differenceInCalendarDays(noon$2(project.endDate), noon$2(project.baselineEnd)) : 0;
+	const likely = tide.kind === "forecast" && tide.likely ? differenceInCalendarDays(noon$3(tide.likely), noon$3(plannedEnd)) : 0;
+	const moved = project.baselineEnd ? differenceInCalendarDays(noon$3(project.endDate), noon$3(project.baselineEnd)) : 0;
 	const slip = Math.max(likely, moved);
 	return slip > 0 ? slip : null;
 }
@@ -3084,7 +3084,7 @@ function barnaclesShort(b) {
 function briefWorthy(b) {
 	return b.from === "baseline" && !b.caveat && b.added >= 3 && (b.share == null || b.share >= .15);
 }
-var SETTLE_DAYS, THIN_PLANNED, THIN_WEEKS, BULK_SHARE, BULK_MIN, BRIEF_MIN_ADDED, BRIEF_MIN_SHARE, noon$2, isoDay$3, plural$7;
+var SETTLE_DAYS, THIN_PLANNED, THIN_WEEKS, BULK_SHARE, BULK_MIN, BRIEF_MIN_ADDED, BRIEF_MIN_SHARE, noon$3, isoDay$3, plural$7;
 var init_barnacles = __esmMin((() => {
 	init_date_fns();
 	init_format();
@@ -3096,7 +3096,7 @@ var init_barnacles = __esmMin((() => {
 	BULK_MIN = 5;
 	BRIEF_MIN_ADDED = 3;
 	BRIEF_MIN_SHARE = .15;
-	noon$2 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+	noon$3 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
 	isoDay$3 = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
 	plural$7 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 }));
@@ -5942,18 +5942,18 @@ init_tide();
 const BURN_DAYS = 56;
 /** A window shorter than a week says too little to read a rate from. */
 const MIN_DAYS = 7;
-const noon$1 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+const noon$2 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
 /**
 * Spend a day over the last BURN_DAYS (or the project's life, when it's
 * younger), from the ledger; null when nothing was spent in that time.
 */
 function burnPerDay(entries, startDate, now) {
-	const today = noon$1(todayISO(now));
-	const age = differenceInCalendarDays(today, noon$1(startDate)) + 1;
+	const today = noon$2(todayISO(now));
+	const age = differenceInCalendarDays(today, noon$2(startDate)) + 1;
 	const span = Math.max(MIN_DAYS, Math.min(56, age));
 	let sum = 0;
 	for (const e of entries) {
-		const back = differenceInCalendarDays(today, noon$1(e.date));
+		const back = differenceInCalendarDays(today, noon$2(e.date));
 		if (back >= 0 && back < span) sum += e.amount;
 	}
 	return sum > 0 ? sum / span : null;
@@ -5975,8 +5975,8 @@ function slipCost(project, tide, entries, now) {
 	const from = project.endDate > today ? project.endDate : today;
 	const point = (date) => {
 		if (!date) return null;
-		const daysLate = Math.max(0, differenceInCalendarDays(noon$1(date), noon$1(from)));
-		const ahead = Math.max(0, differenceInCalendarDays(noon$1(date), noon$1(today)));
+		const daysLate = Math.max(0, differenceInCalendarDays(noon$2(date), noon$2(from)));
+		const ahead = Math.max(0, differenceInCalendarDays(noon$2(date), noon$2(today)));
 		return {
 			date,
 			daysLate,
@@ -6818,6 +6818,534 @@ function applyTheme(name) {
 }
 applyTheme("dark");
 
+// src/lib/signal-flags.ts
+const FLAG_W = 30;
+const FLAG_H = 20;
+const W = 30;
+const H = 20;
+const full = (c) => ({
+	r: [
+		0,
+		0,
+		W,
+		H
+	],
+	c
+});
+const rows = (...cs) => cs.map((c, i) => ({
+	r: [
+		0,
+		H / cs.length * i,
+		W,
+		H / cs.length
+	],
+	c
+}));
+const cols = (...cs) => cs.map((c, i) => ({
+	r: [
+		W / cs.length * i,
+		0,
+		W / cs.length,
+		H
+	],
+	c
+}));
+const quarters = (a, b, c, d) => [
+	{
+		r: [
+			0,
+			0,
+			W / 2,
+			H / 2
+		],
+		c: a
+	},
+	{
+		r: [
+			W / 2,
+			0,
+			W / 2,
+			H / 2
+		],
+		c: b
+	},
+	{
+		r: [
+			0,
+			H / 2,
+			W / 2,
+			H / 2
+		],
+		c
+	},
+	{
+		r: [
+			W / 2,
+			H / 2,
+			W / 2,
+			H / 2
+		],
+		c: d
+	}
+];
+const square = (field, mid, inset = 6) => [full(field), {
+	r: [
+		inset * 1.5,
+		inset,
+		W - inset * 3,
+		H - inset * 2
+	],
+	c: mid
+}];
+const cross = (field, bar, t = 4) => [
+	full(field),
+	{
+		r: [
+			(W - t) / 2,
+			0,
+			t,
+			H
+		],
+		c: bar
+	},
+	{
+		r: [
+			0,
+			(H - t) / 2,
+			W,
+			t
+		],
+		c: bar
+	}
+];
+const saltire = (field, bar) => [
+	full(field),
+	{
+		p: [
+			0,
+			0,
+			3.5,
+			0,
+			W,
+			17.5,
+			W,
+			H,
+			26.5,
+			H,
+			0,
+			2.5
+		],
+		c: bar
+	},
+	{
+		p: [
+			W,
+			0,
+			W,
+			2.5,
+			3.5,
+			H,
+			0,
+			H,
+			0,
+			17.5,
+			26.5,
+			0
+		],
+		c: bar
+	}
+];
+const disc = (field, dot, r = 5.5) => [full(field), {
+	o: [
+		W / 2,
+		H / 2,
+		r
+	],
+	c: dot
+}];
+/** The 26 letter flags. */
+const LETTERS = {
+	A: [
+		"Alfa",
+		cols("w", "b"),
+		["w", "b"]
+	],
+	B: [
+		"Bravo",
+		[full("r")],
+		["r", "r"]
+	],
+	C: [
+		"Charlie",
+		rows("b", "w", "r", "w", "b"),
+		["b", "r"]
+	],
+	D: [
+		"Delta",
+		[full("y"), {
+			r: [
+				0,
+				H / 4,
+				W,
+				H / 2
+			],
+			c: "b"
+		}],
+		["y", "b"]
+	],
+	E: [
+		"Echo",
+		rows("b", "r"),
+		["b", "r"]
+	],
+	F: [
+		"Foxtrot",
+		[full("w"), {
+			p: [
+				W / 2,
+				1,
+				29,
+				H / 2,
+				W / 2,
+				19,
+				1,
+				H / 2
+			],
+			c: "r"
+		}],
+		["w", "r"]
+	],
+	G: [
+		"Golf",
+		cols("y", "b", "y", "b", "y", "b"),
+		["y", "b"]
+	],
+	H: [
+		"Hotel",
+		cols("w", "r"),
+		["w", "r"]
+	],
+	I: [
+		"India",
+		disc("y", "k"),
+		["y", "k"]
+	],
+	J: [
+		"Juliett",
+		rows("b", "w", "b"),
+		["b", "w"]
+	],
+	K: [
+		"Kilo",
+		cols("y", "b"),
+		["y", "b"]
+	],
+	L: [
+		"Lima",
+		quarters("y", "k", "k", "y"),
+		["y", "k"]
+	],
+	M: [
+		"Mike",
+		saltire("b", "w"),
+		["b", "w"]
+	],
+	N: [
+		"November",
+		[full("w"), ...[
+			0,
+			1,
+			2,
+			3
+		].flatMap((row) => [
+			0,
+			1,
+			2,
+			3
+		].filter((col) => (row + col) % 2 === 0).map((col) => ({
+			r: [
+				col * (W / 4),
+				row * (H / 4),
+				W / 4,
+				H / 4
+			],
+			c: "b"
+		})))],
+		["b", "w"]
+	],
+	O: [
+		"Oscar",
+		[full("y"), {
+			p: [
+				0,
+				0,
+				W,
+				0,
+				W,
+				H
+			],
+			c: "r"
+		}],
+		["y", "r"]
+	],
+	P: [
+		"Papa",
+		square("b", "w"),
+		["b", "w"]
+	],
+	Q: [
+		"Quebec",
+		[full("y")],
+		["y", "y"]
+	],
+	R: [
+		"Romeo",
+		cross("r", "y"),
+		["r", "y"]
+	],
+	S: [
+		"Sierra",
+		square("w", "b"),
+		["w", "b"]
+	],
+	T: [
+		"Tango",
+		cols("r", "w", "b"),
+		["r", "b"]
+	],
+	U: [
+		"Uniform",
+		quarters("r", "w", "w", "r"),
+		["r", "w"]
+	],
+	V: [
+		"Victor",
+		saltire("w", "r"),
+		["w", "r"]
+	],
+	W: [
+		"Whiskey",
+		[
+			full("b"),
+			{
+				r: [
+					4,
+					3,
+					22,
+					14
+				],
+				c: "w"
+			},
+			{
+				r: [
+					10,
+					7,
+					10,
+					6
+				],
+				c: "r"
+			}
+		],
+		["b", "r"]
+	],
+	X: [
+		"X-ray",
+		cross("w", "b"),
+		["w", "b"]
+	],
+	Y: [
+		"Yankee",
+		[full("y"), ...[
+			-20,
+			-10,
+			0,
+			10,
+			20,
+			30
+		].map((x) => ({
+			p: [
+				x,
+				H,
+				x + 5,
+				H,
+				x + 25,
+				0,
+				x + 20,
+				0
+			],
+			c: "r"
+		}))],
+		["y", "r"]
+	],
+	Z: [
+		"Zulu",
+		[
+			{
+				p: [
+					0,
+					0,
+					W,
+					0,
+					W / 2,
+					H / 2
+				],
+				c: "y"
+			},
+			{
+				p: [
+					W,
+					0,
+					W,
+					H,
+					W / 2,
+					H / 2
+				],
+				c: "b"
+			},
+			{
+				p: [
+					0,
+					H,
+					W,
+					H,
+					W / 2,
+					H / 2
+				],
+				c: "r"
+			},
+			{
+				p: [
+					0,
+					0,
+					W / 2,
+					H / 2,
+					0,
+					H
+				],
+				c: "k"
+			}
+		],
+		["k", "b"]
+	]
+};
+/** The ten numeral pennants. */
+const DIGITS = {
+	"0": [
+		"Zero",
+		cols("y", "r", "y"),
+		["y", "r"]
+	],
+	"1": [
+		"One",
+		disc("w", "r", 4),
+		["w", "r"]
+	],
+	"2": [
+		"Two",
+		disc("b", "w", 4),
+		["b", "w"]
+	],
+	"3": [
+		"Three",
+		cols("r", "w", "b"),
+		["r", "b"]
+	],
+	"4": [
+		"Four",
+		cross("r", "w", 3.5),
+		["r", "w"]
+	],
+	"5": [
+		"Five",
+		cols("y", "b"),
+		["y", "b"]
+	],
+	"6": [
+		"Six",
+		rows("k", "w"),
+		["k", "w"]
+	],
+	"7": [
+		"Seven",
+		rows("y", "r"),
+		["y", "r"]
+	],
+	"8": [
+		"Eight",
+		cross("w", "r", 3.5),
+		["w", "r"]
+	],
+	"9": [
+		"Nine",
+		quarters("w", "k", "r", "y"),
+		["w", "y"]
+	]
+};
+/** One flag, or null for a character the code has no flag for. */
+function signalFlag(char) {
+	const c = char.toUpperCase();
+	const letter = LETTERS[c];
+	if (letter) {
+		const [name, shapes, halves] = letter;
+		return {
+			char: c,
+			name,
+			shapes,
+			halves,
+			outline: c === "A" || c === "B" ? "swallowtail" : "flag"
+		};
+	}
+	const digit = DIGITS[c];
+	if (digit) {
+		const [name, shapes, halves] = digit;
+		return {
+			char: c,
+			name,
+			shapes,
+			halves,
+			outline: "pennant"
+		};
+	}
+	return null;
+}
+/** The most flags a hoist shows; longer keys keep their first four characters. */
+const MAX_FLAGS = 4;
+/** A key's flags, in order: letters and digits only, at most four. */
+function flagsFor(key) {
+	if (!key) return [];
+	const out = [];
+	for (const ch of key) {
+		const flag = signalFlag(ch);
+		if (flag) out.push(flag);
+		if (out.length === 4) break;
+	}
+	return out;
+}
+/** The flag an off-track project flies under its key. */
+const ASSISTANCE_FLAG = "V";
+/** "Romeo Romeo", read the way a signaller would say the hoist. */
+function spokenHoist(flags) {
+	return flags.map((f) => f.name).join(" ");
+}
+/**
+* What the hoist says on hover: the key, how it's spoken, and, when the
+* project is off track, Victor's meaning.
+*/
+function hoistLabel(key, flags, offTrack) {
+	const base = `${key} in signal flags: ${spokenHoist(flags)}`;
+	return offTrack ? `${base}, flying Victor, “I require assistance”` : base;
+}
+/** The flags a project flies: its key, plus Victor while it's off track. */
+function projectHoist(key, offTrack) {
+	const flags = flagsFor(key);
+	if (!flags.length || !key) return null;
+	return {
+		flags,
+		assist: offTrack ? signalFlag("V") : null,
+		label: hoistLabel(key, flags, offTrack)
+	};
+}
+
 // src/tui/ui.tsx
 /**
 * The terminal app's small parts: a one-line text field, a list to pick
@@ -7002,6 +7530,33 @@ function Heading({ children, right }) {
 		}) : null]
 	});
 }
+/** The signal flags' five colours as a terminal draws them. */
+const FLAG_TERM = {
+	r: "#d0533a",
+	b: "#2f62a8",
+	y: "#e8b230",
+	k: "#1f1e1d",
+	w: "#f3f1ea"
+};
+/**
+* A project's key in signal flags, one cell a flag: the left half the
+* hoist's colour, the right half the fly's (Victor after a gap when the
+* project is off track). Rough, but recognisably the same emblem.
+*/
+function FlagHoist({ code, health }) {
+	const hoist = projectHoist(code, health === "off-track");
+	if (!hoist) return null;
+	const all = hoist.assist ? [
+		...hoist.flags,
+		null,
+		hoist.assist
+	] : hoist.flags;
+	return /* @__PURE__ */ jsx(Text, { children: all.map((f, i) => f ? /* @__PURE__ */ jsx(Text, {
+		color: FLAG_TERM[f.halves[0]],
+		backgroundColor: FLAG_TERM[f.halves[1]],
+		children: "▌"
+	}, i) : /* @__PURE__ */ jsx(Text, { children: " " }, i)) });
+}
 
 // src/tui/forms.tsx
 /**
@@ -9581,11 +10136,11 @@ function hillText(project) {
 	if (at === 100) return "Over the hill: done";
 	return `${HILL_PHASE_LABEL[hillPhase(at)]} (${at} of 100)`;
 }
-var HILL_TOP, STILL_DAYS, HILL_PHASE_LABEL;
+var HILL_TOP, STILL_DAYS$1, HILL_PHASE_LABEL;
 var init_hill = __esmMin((() => {
 	init_date_fns();
 	HILL_TOP = 50;
-	STILL_DAYS = 14;
+	STILL_DAYS$1 = 14;
 	HILL_PHASE_LABEL = {
 		figuring: "Figuring it out",
 		doing: "Getting it done"
@@ -14252,6 +14807,12 @@ function taskMinutes(task) {
 function entriesNewestFirst(task) {
 	return [...task.time ?? []].sort((a, b) => (b.on + b.at).localeCompare(a.on + a.at));
 }
+/** The ISO day `n` days before `iso`. */
+function daysBefore(iso, n) {
+	const d = /* @__PURE__ */ new Date(`${iso}T12:00:00Z`);
+	d.setUTCDate(d.getUTCDate() - n);
+	return d.toISOString().slice(0, 10);
+}
 
 // src/lib/goals.ts
 init_indexes();
@@ -20228,8 +20789,8 @@ init_date_fns();
 init_blockers();
 init_format();
 init_indexes();
-const noon = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
-const days$2 = (from, to) => differenceInCalendarDays(noon(to), noon(from));
+const noon$1 = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+const days$2 = (from, to) => differenceInCalendarDays(noon$1(to), noon$1(from));
 const later = (a, b) => !a ? b : !b ? a : a >= b ? a : b;
 const open = (t) => t.status !== "done";
 /** True when `a` finishes later than `b`, or as late behind a longer line. */
@@ -21260,8 +21821,349 @@ var init_fog = __esmMin((() => {
 	fileCache = /* @__PURE__ */ new WeakMap();
 }));
 
-// src/lib/task-approval.ts
+// src/lib/assignment.ts
+/**
+* Record who set a task's assignee and when. Only a change of assignee
+* stamps; clearing the assignee clears the stamp.
+*/
+function stampAssignment(before, next, by, at) {
+	if (before && before.assigneeId === next.assigneeId) return next;
+	if (!next.assigneeId) return {
+		...next,
+		assignedBy: null,
+		assignedAt: null
+	};
+	return {
+		...next,
+		assignedBy: by,
+		assignedAt: at
+	};
+}
+var init_assignment = __esmMin((() => {}));
+
+// src/lib/scuttle-rows.ts
+/** Whether it's scuttled: closed through Scuttle or sail and not raised since. */
+function isScuttled(project) {
+	return Boolean(project.scuttled) && project.healthOverride === "done";
+}
+/**
+* Scuttle a project: Done by hand with the reason as its note, its open
+* tasks unassigned and undated (kept in `scuttled.freed`), and a decision on
+* the register. Null for a project that's already scuttled or gone, or a
+* blank why.
+*/
+function scuttleRows(data, projectId, why, byId, at, decisionId, context = "Closed through Scuttle or sail.") {
+	const project = data.projects.find((p) => p.id === projectId);
+	const reason = why.trim().slice(0, 600);
+	if (!project || !reason || isScuttled(project)) return null;
+	const freed = [];
+	const tasks = [];
+	for (const t of tasksOf(data.tasks, projectId)) {
+		if (t.status === "done" || !t.assigneeId && !t.dueDate) continue;
+		freed.push({
+			taskId: t.id,
+			assigneeId: t.assigneeId,
+			dueDate: t.dueDate
+		});
+		tasks.push(stampAssignment(t, {
+			...t,
+			assigneeId: null,
+			dueDate: null,
+			touchedAt: at
+		}, byId, at));
+	}
+	const decision = normalizeRaidItem({
+		id: decisionId,
+		kind: "decision",
+		projectId,
+		title: `Scuttle ${project.name}`,
+		description: context,
+		status: "decided",
+		severity: "low",
+		ownerId: byId,
+		dueDate: null,
+		resolution: "Stop the project. Its open tasks come off people’s lists.",
+		rationale: reason,
+		decidedById: byId,
+		decidedAt: at,
+		createdById: byId,
+		createdAt: at,
+		updatedAt: at,
+		updates: []
+	});
+	return {
+		project: {
+			...project,
+			health: "done",
+			healthOverride: "done",
+			healthNote: `Scuttled: ${reason}`,
+			scuttled: {
+				at,
+				byId,
+				why: reason,
+				decisionId,
+				freed
+			}
+		},
+		tasks,
+		decision
+	};
+}
+/**
+* Raise a scuttled project: the scuttle cleared (the caller clears its Done), and each
+* freed task given back its person and date, unless someone has since given
+* it others, it's done, or the person has left the crew. Null when it isn't
+* scuttled.
+*/
+function raiseRows(data, projectId, at, byId) {
+	const project = data.projects.find((p) => p.id === projectId);
+	if (!project?.scuttled) return null;
+	const people = new Set(data.people.map((p) => p.id));
+	const byTask = new Map(project.scuttled.freed.map((f) => [f.taskId, f]));
+	const tasks = [];
+	for (const t of tasksOf(data.tasks, projectId)) {
+		const f = byTask.get(t.id);
+		if (!f || t.status === "done") continue;
+		const assigneeId = !t.assigneeId && f.assigneeId && people.has(f.assigneeId) ? f.assigneeId : t.assigneeId;
+		const dueDate = t.dueDate ?? f.dueDate;
+		if (assigneeId === t.assigneeId && dueDate === t.dueDate) continue;
+		tasks.push(stampAssignment(t, {
+			...t,
+			assigneeId,
+			dueDate,
+			touchedAt: at
+		}, byId, at));
+	}
+	return {
+		project: {
+			...project,
+			scuttled: null,
+			voyageCall: {
+				call: "sail",
+				at,
+				byId
+			}
+		},
+		tasks
+	};
+}
+var WHY_MAX;
+var init_scuttle_rows = __esmMin((() => {
+	init_assignment();
+	init_indexes();
+	init_raid();
+	WHY_MAX = 600;
+}));
+
+// src/lib/scuttle.ts
+init_date_fns();
 init_fog();
+init_indexes();
+init_scuttle_rows();
+init_spend();
+init_format();
+/** Days with nothing moving before a project reads as still. */
+const STILL_DAYS = 28;
+/** A project younger than this is left alone: it's still being set up. */
+const YOUNG_DAYS = 21;
+/** Sailing on or a refit keeps it out of the line-up this long. */
+const QUIET_DAYS = 90;
+/** Slips are counted over this window. */
+const SLIP_WINDOW_DAYS = 90;
+/** This many falls into trouble in the window reads as slipping again and again. */
+const SLIP_TIMES = 3;
+/** Its end date this far past the baseline reads as drifting. */
+const DRIFT_DAYS = 21;
+/** This far past its end date with work open. */
+const OVERDUE_DAYS = 14;
+/** Paused this long. */
+const PAUSED_DAYS = 30;
+const noon = (iso) => /* @__PURE__ */ new Date(`${iso.slice(0, 10)}T12:00:00`);
+const daysSince = (iso, today) => differenceInCalendarDays(noon(today), noon(iso));
+const TRACK = {
+	"on-track": 0,
+	"at-risk": 1,
+	"off-track": 2
+};
+/** When anything last moved on the project: its tasks (as fog reads them) and its hill dot. */
+function lastMoved(project, data) {
+	let last = project.hillMovedAt ?? null;
+	for (const t of tasksOf(data.tasks, project.id)) {
+		const at = lastTouch(t, data);
+		if (!last || at > last) last = at;
+	}
+	return last;
+}
+/** Times its health fell (on track to at risk or off track, at risk to off track) since `since`. */
+function slipsSince(project, since) {
+	let times = 0;
+	let prev;
+	for (const line of project.healthHistory ?? []) {
+		const rank = TRACK[line.health];
+		if (rank === void 0) {
+			prev = void 0;
+			continue;
+		}
+		if (prev !== void 0 && rank > prev && line.at.slice(0, 10) >= since) times += 1;
+		prev = rank;
+	}
+	return times;
+}
+/** Days it has been paused, from the history's latest line saying so; null when it isn't, or nobody knows since when. */
+function pausedDays(project, today) {
+	if (project.health !== "paused") return null;
+	const history = project.healthHistory ?? [];
+	let since = null;
+	for (let i = history.length - 1; i >= 0; i--) {
+		if (history[i].health !== "paused") break;
+		since = history[i].at;
+	}
+	return since ? Math.max(0, daysSince(since, today)) : null;
+}
+/** A goal's work key result names it or its program. Only asked when its portfolio has goals at all. */
+function aimless(project, data) {
+	const program = data.programs.find((p) => p.id === project.programId);
+	const goals = (program && data.portfolios.find((p) => p.id === program.portfolioId))?.goals ?? [];
+	if (goals.length === 0) return false;
+	return !goals.some((g) => g.keyResults.some((kr) => kr.kind === "work" && (kr.linkIds ?? []).some((id) => id === project.id || id === project.programId)));
+}
+const STRENGTH = {
+	overdue: 0,
+	still: 1,
+	empty: 1,
+	paused: 2,
+	slipping: 3,
+	drifted: 4,
+	aimless: 5
+};
+/** The signs that put a project in the line-up today, strongest first; empty when it's sailing fine. */
+function zombieSigns(project, data, today) {
+	const signs = [];
+	const tasks = tasksOf(data.tasks, project.id);
+	const open = tasks.filter((t) => t.status !== "done").length;
+	const age = daysSince(project.startDate, today);
+	if (tasks.length === 0) {
+		if (age >= 28) signs.push({
+			kind: "empty",
+			days: age
+		});
+	} else if (project.health !== "paused") {
+		const moved = lastMoved(project, data);
+		const still = moved ? daysSince(moved, today) : age;
+		if (still >= 28) signs.push({
+			kind: "still",
+			days: still
+		});
+	}
+	const paused = pausedDays(project, today);
+	if (paused !== null && paused >= 30) signs.push({
+		kind: "paused",
+		days: paused
+	});
+	const late = daysSince(project.endDate, today);
+	if (open > 0 && late >= 14 && project.health !== "paused") signs.push({
+		kind: "overdue",
+		days: late,
+		open
+	});
+	const slips = slipsSince(project, daysBefore(today, 90));
+	if (slips >= 3) signs.push({
+		kind: "slipping",
+		times: slips
+	});
+	if (project.baselineEnd) {
+		const drift = differenceInCalendarDays(noon(project.endDate), noon(project.baselineEnd));
+		if (drift >= 21) signs.push({
+			kind: "drifted",
+			days: drift
+		});
+	}
+	if (signs.length > 0 && aimless(project, data)) signs.push({ kind: "aimless" });
+	return signs.sort((a, b) => STRENGTH[a.kind] - STRENGTH[b.kind]);
+}
+/** Left out of the line-up: finished, scuttled, too young, or answered within the quarter. */
+function restingFromReview(project, today) {
+	if (project.health === "done" || isScuttled(project)) return true;
+	if (project.startDate > today || daysSince(project.startDate, today) < 21) return true;
+	const call = project.voyageCall;
+	return Boolean(call && daysSince(call.at, today) < 90);
+}
+/** What scuttling it would free: open tasks by person, logged hours and spend a week. */
+function whatItHolds(project, data, now) {
+	const today = todayISO(now);
+	const tasks = tasksOf(data.tasks, project.id);
+	const by = /* @__PURE__ */ new Map();
+	let openTasks = 0;
+	let minutes = 0;
+	const from = daysBefore(today, 27);
+	for (const t of tasks) {
+		for (const e of t.time ?? []) if (e.on >= from && e.on <= today) minutes += e.minutes;
+		if (t.status === "done") continue;
+		openTasks += 1;
+		if (t.assigneeId) by.set(t.assigneeId, (by.get(t.assigneeId) ?? 0) + 1);
+	}
+	const crew = [...by].map(([personId, open]) => ({
+		personId,
+		open
+	})).sort((a, b) => b.open - a.open);
+	const burn = project.budget > 0 ? burnPerDay(spendEntriesOf({ spendEntries: data.spendEntries ?? [] }, project.id), project.startDate, now) : null;
+	return {
+		openTasks,
+		crew,
+		hoursPerWeek: minutes > 0 ? Math.round(minutes / 60 / 4 * 10) / 10 : null,
+		spendPerWeek: burn ? Math.round(burn * 7) : null
+	};
+}
+/**
+* The line-up: projects showing a zombie sign that aren't resting, the ones
+* with the most signs first, then the stillest. `projectIds` narrows it to a
+* portfolio's or program's; leave it out for the whole harbor.
+*/
+function scuttleLineUp(data, now, projectIds) {
+	const today = todayISO(now);
+	const out = [];
+	for (const project of data.projects) {
+		if (projectIds && !projectIds.has(project.id)) continue;
+		if (restingFromReview(project, today)) continue;
+		const signs = zombieSigns(project, data, today);
+		if (signs.length === 0) continue;
+		out.push({
+			project,
+			signs,
+			lastMoved: lastMoved(project, data),
+			...whatItHolds(project, data, now)
+		});
+	}
+	const still = (z) => {
+		const s = z.signs.find((x) => x.kind === "still" || x.kind === "empty");
+		return s && "days" in s ? s.days : 0;
+	};
+	return out.sort((a, b) => b.signs.length - a.signs.length || still(b) - still(a) || a.project.name.localeCompare(b.project.name));
+}
+/** The projects in a portfolio or a program, for narrowing the line-up. */
+function projectIdsUnder(data, scope) {
+	const programs = new Set(scope.programId ? [scope.programId] : data.programs.filter((p) => p.portfolioId === scope.portfolioId).map((p) => p.id));
+	return new Set(data.projects.filter((p) => programs.has(p.programId)).map((p) => p.id));
+}
+/** "6 weeks", "10 days". */
+function spanText(days) {
+	if (days >= 14) return `${Math.floor(days / 7)} weeks`;
+	return `${days} day${days === 1 ? "" : "s"}`;
+}
+/** One sign in a short sentence. */
+function signText(sign) {
+	switch (sign.kind) {
+		case "still": return `Nothing has moved in ${spanText(sign.days)}`;
+		case "empty": return `No tasks, ${spanText(sign.days)} after it started`;
+		case "slipping": return `Slipped into trouble ${sign.times} times in three months`;
+		case "drifted": return `Its end date has moved ${spanText(sign.days)} past the plan`;
+		case "overdue": return `${spanText(sign.days)} past its end date, ${sign.open} task${sign.open === 1 ? "" : "s"} still open`;
+		case "paused": return `Paused for ${spanText(sign.days)}`;
+		case "aimless": return "No goal behind it";
+	}
+}
+
+// src/lib/task-approval.ts
 /** Waits on its approver now: asked, not yet answered, and not done. */
 function awaitingApproval(task) {
 	return Boolean(task?.approval && task.approval.status === "pending" && task.status !== "done");
@@ -21298,6 +22200,7 @@ init_handover();
 init_agents();
 init_work();
 init_task_people();
+init_fog();
 init_passage();
 init_board();
 init_holidays();
@@ -23138,6 +24041,53 @@ const HARBOR_TOOLS = [
 			};
 		}
 	}),
+	tool({
+		name: "scuttle_or_sail",
+		title: "Projects that look adrift",
+		description: "Scuttle or sail: running projects that look like zombies (nothing moved for four weeks, no tasks a month in, two weeks past the end with work open, paused for a month, slipped into trouble three times in three months, or the end date moved three weeks past the baseline; \"no goal behind it\" is added when the portfolio keeps goals), the most signs first. Each says what stopping it would free: open tasks by person, logged hours a week, spend a week. Projects someone kept or refitted in the last three months, finished ones and ones under three weeks old are left out. Walk the person through them one at a time; answer_scuttle_or_sail records sail on, refit or scuttle, only on their word." + DATA_NOTE,
+		input: object({
+			harbor: harborArg,
+			portfolio: string().max(200).optional().describe("Portfolio id or name, for its projects only."),
+			program: string().max(200).optional().describe("Program id or name, for its projects only."),
+			limit: limitArg(100, 25),
+			offset: offsetArg
+		}),
+		run: (ctx, input) => {
+			const { data } = ctx;
+			const program = input.program ? findOne(data.programs, input.program, "program") : null;
+			const portfolio = !program && input.portfolio ? findOne(data.portfolios, input.portfolio, "portfolio") : null;
+			const ids = program || portfolio ? projectIdsUnder(data, {
+				programId: program?.id,
+				portfolioId: portfolio?.id
+			}) : void 0;
+			const lineUp = scuttleLineUp(data, ctx.now, ids);
+			const people = byId(data.people);
+			return {
+				...program ? { program: program.name } : portfolio ? { portfolio: portfolio.name } : {},
+				adrift: lineUp.length,
+				projects: lineUp.slice(input.offset, input.offset + input.limit).map((z) => ({
+					project: z.project.name,
+					...z.project.key ? { key: z.project.key } : {},
+					health: z.project.health,
+					endDate: z.project.endDate,
+					owner: people.get(z.project.ownerId)?.name ?? null,
+					signs: z.signs.map((s) => ({
+						kind: s.kind,
+						text: signText(s)
+					})),
+					lastMoved: dayOf(z.lastMoved),
+					openTasks: z.openTasks,
+					crew: z.crew.map((c) => ({
+						person: people.get(c.personId)?.name ?? null,
+						openTasks: c.open
+					})),
+					hoursPerWeek: z.hoursPerWeek,
+					spendPerWeek: z.spendPerWeek
+				})),
+				more: lineUp.length > input.offset + input.limit
+			};
+		}
+	}),
 	tool({
 		name: "lifeboats",
 		title: "Work only one person knows",
@@ -23932,26 +24882,6 @@ var init_session = __esmMin((() => {
 	init_format();
 }));
 
-// src/lib/assignment.ts
-/**
-* Record who set a task's assignee and when. Only a change of assignee
-* stamps; clearing the assignee clears the stamp.
-*/
-function stampAssignment(before, next, by, at) {
-	if (before && before.assigneeId === next.assigneeId) return next;
-	if (!next.assigneeId) return {
-		...next,
-		assignedBy: null,
-		assignedAt: null
-	};
-	return {
-		...next,
-		assignedBy: by,
-		assignedAt: at
-	};
-}
-var init_assignment = __esmMin((() => {}));
-
 // src/lib/first-week.ts
 /** The program launch named for you, when nobody has renamed it yet. */
 function starterProgram(data) {
@@ -23963,6 +24893,33 @@ var init_first_week = __esmMin((() => {
 
 // src/lib/slices/hierarchy.ts
 function hierarchySlice({ get, write }) {
+	/**
+	* A scuttled project being reopened (its Done cleared or changed): its
+	* freed tasks get their people and dates back, and its decision says so.
+	* Null when it isn't scuttled.
+	*/
+	const raise = (projectId, at) => {
+		const s = get();
+		const rows = raiseRows(s, projectId, at, s.currentUserId);
+		if (!rows) return null;
+		const changed = new Map(rows.tasks.map((t) => [t.id, t]));
+		const decisionId = s.projects.find((p) => p.id === projectId)?.scuttled?.decisionId;
+		const note = {
+			id: uid("ru"),
+			authorId: s.currentUserId,
+			body: "Raised again: the project is back, and its tasks went back to their people.",
+			createdAt: at
+		};
+		return {
+			projects: s.projects.map((p) => p.id === projectId ? rows.project : p),
+			tasks: s.tasks.map((t) => changed.get(t.id) ?? t),
+			raidItems: s.raidItems.map((r) => r.id === decisionId ? {
+				...r,
+				updates: [...r.updates, note],
+				updatedAt: at
+			} : r)
+		};
+	};
 	return {
 		addPortfolio: (p) => {
 			const id = uid("pf");
@@ -24207,11 +25164,24 @@ function hierarchySlice({ get, write }) {
 					programs: get().programs.map((p) => p.id === id ? mark(p) : p),
 					projects: parked ? get().projects.map((p) => p.programId === id && (!p.healthOverride || p.healthOverride === "paused" || p.healthOverride === "done") ? mark(p) : p) : get().projects
 				});
-			} else write({ projects: get().projects.map((p) => p.id === id ? mark(p) : p) });
+			} else {
+				const raised = health === "done" ? null : raise(id, at);
+				write({
+					projects: (raised?.projects ?? get().projects).map((p) => p.id === id ? mark(p) : p),
+					...raised ? {
+						tasks: raised.tasks,
+						raidItems: raised.raidItems
+					} : {}
+				});
+			}
 		},
 		clearHealthOverride: (kind, id) => {
 			const at = stamp();
-			const s = get();
+			const raised = kind === "project" ? raise(id, at) : null;
+			const s = raised ? {
+				...get(),
+				...raised
+			} : get();
 			const cleared = {
 				portfolio: /* @__PURE__ */ new Set(),
 				program: /* @__PURE__ */ new Set(),
@@ -24246,9 +25216,59 @@ function hierarchySlice({ get, write }) {
 			write({
 				portfolios: next.portfolios.map(byRules("portfolio")),
 				programs: next.programs.map(byRules("program")),
-				projects: next.projects.map(byRules("project"))
+				projects: next.projects.map(byRules("project")),
+				...raised ? {
+					tasks: raised.tasks,
+					raidItems: raised.raidItems
+				} : {}
 			});
 		},
+		scuttleProject: (projectId, why, context) => {
+			const s = get();
+			const at = stamp();
+			const decisionId = uid("raid");
+			const rows = scuttleRows(s, projectId, why, s.currentUserId, at, decisionId, context);
+			if (!rows) return null;
+			const before = s.projects.find((p) => p.id === projectId);
+			const changed = new Map(rows.tasks.map((t) => [t.id, t]));
+			write({
+				projects: s.projects.map((p) => p.id === projectId ? {
+					...rows.project,
+					healthHistory: recordHealth(p.healthHistory, "done", at, true, rows.project.healthNote)
+				} : p),
+				tasks: s.tasks.map((t) => changed.get(t.id) ?? t),
+				raidItems: [...s.raidItems, rows.decision]
+			});
+			get().log(`scuttled ${before.name}`, `/projects/${projectId}`);
+			return {
+				project: before,
+				tasks: s.tasks.filter((t) => changed.has(t.id)),
+				decisionId
+			};
+		},
+		undoScuttle: (undo) => {
+			const s = get();
+			const back = new Map(undo.tasks.map((t) => [t.id, t]));
+			write({
+				projects: s.projects.map((p) => p.id === undo.project.id ? undo.project : p),
+				tasks: s.tasks.map((t) => back.get(t.id) ?? t),
+				raidItems: s.raidItems.filter((r) => r.id !== undo.decisionId)
+			});
+		},
+		answerVoyage: (projectId, call, note) => {
+			const at = stamp();
+			const byId = get().currentUserId;
+			const text = note?.trim().slice(0, 300);
+			write({ projects: get().projects.map((p) => p.id === projectId ? {
+				...p,
+				voyageCall: {
+					call,
+					at,
+					byId,
+					...text ? { note: text } : {}
+				}
+			} : p) });
+		},
 		snapshotBaseline: (programId, reset = false) => {
 			const inProgram = new Set(get().projects.filter((p) => p.programId === programId).map((p) => p.id));
 			const stamped = withBaseline(get().projects.filter((p) => inProgram.has(p.id)), reset, stamp());
@@ -24406,6 +25426,7 @@ var init_hierarchy = __esmMin((() => {
 	init_derived_health();
 	init_shared();
 	init_assignment();
+	init_scuttle_rows();
 	init_hill();
 	init_charter_lines();
 	init_format();
@@ -30174,6 +31195,11 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 								children: project.key
 							}),
 							" ",
+							/* @__PURE__ */ jsx(FlagHoist, {
+								code: project.key,
+								health: project.health
+							}),
+							" ",
 							/* @__PURE__ */ jsx(HealthMark, {
 								health: project.health,
 								label: true