@harborppm/cli 0.96.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,
@@ -10136,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"
@@ -14807,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();
@@ -20783,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. */
@@ -21815,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");
@@ -21853,6 +22200,7 @@ init_handover();
 init_agents();
 init_work();
 init_task_people();
+init_fog();
 init_passage();
 init_board();
 init_holidays();
@@ -23693,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",
@@ -24487,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) {
@@ -24518,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");
@@ -24762,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(),
@@ -24801,8 +25216,58 @@ 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));
@@ -24961,6 +25426,7 @@ var init_hierarchy = __esmMin((() => {
 	init_derived_health();
 	init_shared();
 	init_assignment();
+	init_scuttle_rows();
 	init_hill();
 	init_charter_lines();
 	init_format();

package/lib/cli.mjs

@@ -54,6 +54,8 @@ import {
   catchupText,
   handoverText,
   fogText,
+  scuttleText,
+  scuttleCallText,
   agentWorkText,
   raidDetail,
   raidList,
@@ -295,6 +297,13 @@ export const HELP = `harbor: Harbor from the terminal
   harbor fog --sweep [--project P]            one at a time: still needed, a
                                               new date, or drop it
   harbor fog keep TASK                        it's still needed: out of the fog
+  harbor scuttle [--program P|--portfolio P]  projects that look adrift: still
+                                              for weeks, slipping, long late
+  harbor scuttle sail|refit PROJECT [--end DATE] [--note TEXT]
+                                              keep it, or refit it, for three
+                                              months out of the line-up
+  harbor scuttle PROJECT --why "TEXT"         stop it on purpose: Done, on the
+                                              register, its tasks set free
   harbor watch [--project P] [--bell]         a live ticker of the harbor's
                                               changes; yours bright, q stops
   harbor watch --once [--since TIME] [--json] the latest changes (or all since
@@ -1149,6 +1158,24 @@ const DETAIL = {
     "  The sweep needs a terminal and full access (harbor login without",
     "  --read-only), since dropping a task deletes it.",
   ],
+  scuttle: [
+    "  harbor scuttle [--program P]           reads: running projects that look",
+    "                 [--portfolio P]         adrift (nothing moved for four",
+    "                                         weeks, slipping again and again, long",
+    "                                         past the end, paused for a month),",
+    "                                         and what stopping each would free",
+    "  harbor scuttle sail PROJECT            writes: keep it sailing; it leaves",
+    "                                         the line-up for three months",
+    "  harbor scuttle refit PROJECT           writes: a new end date and/or a line",
+    '                 [--end DATE] [--note "TEXT"]  on what changes',
+    '  harbor scuttle PROJECT --why "TEXT"    writes: stop it. It closes as Done',
+    "                                         with the why as its note, a decision",
+    "                                         goes on the register, and its open",
+    "                                         tasks come off people's lists",
+    "",
+    "  Nothing is deleted: harbor health auto --project P raises a scuttled project",
+    "  again and gives its tasks back.",
+  ],
   watch: [
     "  harbor watch                           reads, live: each change to the harbor",
     "                                         as it lands, one line with its time",
@@ -3579,6 +3606,49 @@ export async function run(argv, io = {}) {
       }
       return call("fog", { harbor, project: values.project, limit: 100 }, (r) => fogText(r));
     }
+    case "scuttle": {
+      const { positionals, values, harbor } = parse(
+        spec(["list"], ["program", "portfolio", "end", "note", "why"]),
+      );
+      const [first, ...rest] = positionals;
+      if (first === "sail" || first === "refit") {
+        if (values.why !== undefined)
+          throw new HarborError(`--why goes with scuttling: harbor scuttle PROJECT --why "TEXT".`);
+        const project = one(rest, "project");
+        if (first === "sail" && (values.end !== undefined || values.note !== undefined))
+          throw new HarborError("--end and --note go with a refit: harbor scuttle refit PROJECT --end DATE.");
+        if (first === "refit" && values.end === undefined && values.note === undefined)
+          throw new HarborError('A refit needs --end DATE or --note "what changes".');
+        return call(
+          "answer_scuttle_or_sail",
+          {
+            harbor,
+            project,
+            call: first,
+            ...(values.end !== undefined ? { endDate: dueDate(values.end) } : {}),
+            ...(values.note !== undefined ? { note: values.note } : {}),
+          },
+          scuttleCallText,
+        );
+      }
+      if (first !== undefined) {
+        const project = one(positionals, "project");
+        if (values.why === undefined || !values.why.trim())
+          throw new HarborError(
+            `Say why it stops: harbor scuttle ${project} --why "TEXT". To keep it: harbor scuttle sail ${project}.`,
+          );
+        return call(
+          "answer_scuttle_or_sail",
+          { harbor, project, call: "scuttle", why: values.why },
+          scuttleCallText,
+        );
+      }
+      return call(
+        "scuttle_or_sail",
+        { harbor, program: values.program, portfolio: values.portfolio, limit: 100 },
+        scuttleText,
+      );
+    }
     case "bridge": {
       const { positionals, values, harbor } = parse(spec(["list"], ["program"]));
       none(positionals);

package/lib/format.mjs

@@ -1124,6 +1124,45 @@ export function fogText(r, { sweepHint = true } = {}) {
   return lines.join("\n");
 }
 
+/** harbor scuttle: projects that look adrift, with what stopping each would free. */
+export function scuttleText(r) {
+  const where = r.program ? ` in ${r.program}` : r.portfolio ? ` in ${r.portfolio}` : "";
+  if (!r.adrift)
+    return `Nothing looks adrift${where}: every running project has moved lately, and none keeps slipping.`;
+  const lines = [
+    `${r.adrift} ${r.adrift === 1 ? "project looks" : "projects look"} adrift${where}. Keep each sailing, refit it, or stop it on purpose.`,
+    "",
+  ];
+  for (const p of r.projects) {
+    lines.push(
+      `  ${(p.key ?? "").padEnd(5)} ${p.project}${p.owner ? ` · ${p.owner}` : ""} · ends ${p.endDate}`,
+    );
+    for (const s of p.signs) lines.push(`        ${s.text}`);
+    const frees = [
+      `${p.openTasks} open task${p.openTasks === 1 ? "" : "s"}`,
+      p.crew.length ? `with ${p.crew.map((c) => c.person).filter(Boolean).join(", ")}` : null,
+      p.hoursPerWeek ? `${p.hoursPerWeek}h a week logged` : null,
+      p.spendPerWeek ? `$${p.spendPerWeek.toLocaleString("en-US")} a week of spend` : null,
+    ];
+    lines.push(`        holds ${frees.filter(Boolean).join(" · ")}`);
+  }
+  if (r.more) lines.push("", `And ${r.adrift - r.projects.length} more.`);
+  lines.push(
+    "",
+    'harbor scuttle sail PROJECT keeps one, harbor scuttle refit PROJECT --end DATE refits it, harbor scuttle PROJECT --why "TEXT" stops it.',
+  );
+  return lines.join("\n");
+}
+
+/** What harbor scuttle sail, refit or PROJECT --why did. */
+export function scuttleCallText(r) {
+  if (r.call === "scuttle")
+    return `Scuttled ${r.project}. ${r.sendOff} The why is on the register as a decision; harbor health auto --project "${r.project}" raises it again.`;
+  if (r.call === "refit")
+    return `Refitted ${r.project}: ${r.note ?? `ends ${r.endDate}`}. It's out of the line-up until ${r.quietUntil}.`;
+  return `${r.project} sails on. It's out of the line-up until ${r.quietUntil}.`;
+}
+
 /** harbor lifeboats: work only one person knows, numbered for harbor lifeboats N. */
 export function lifeboatsText(r) {
   const where = r.program ? ` in ${r.program}` : "";

package/package.json

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