@harborppm/cli 0.47.0 → 0.49.0

package/dist/app.mjs

@@ -3028,10 +3028,118 @@ function forecastRollup(items, budget, now) {
 	};
 }
 
+//#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$1(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;
+}
+/** 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
@@ -3106,6 +3214,47 @@ function simulate(remaining, weekly, seed, pace = 1) {
 	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) {
+	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);
+	}
+	return {
+		floors,
+		sounded: draws.length
+	};
+}
+/**
 * `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).
 */
@@ -3132,7 +3281,8 @@ function tideForecast(project, tasks, now, opts = {}) {
 		if (!lastDue || t.dueDate > lastDue.dueDate) lastDue = t;
 	}
 	const floor = lastDue ? differenceInCalendarDays(noon$1(lastDue.dueDate), base) : 0;
-	const runs = floor > 0 ? paced.map((d) => Math.max(d, floor)) : paced;
+	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$1(project.endDate), base);
@@ -3160,7 +3310,8 @@ function tideForecast(project, tasks, now, opts = {}) {
 		chanceByEnd: Math.round(byEnd * 100) / 100,
 		curve,
 		rough: finished < ROUGH_BELOW,
-		heldBy
+		heldBy,
+		sounded: sounded.sounded
 	};
 }
 /** "15%", with "under 5%" and "over 95%" at the ends, where a thousand runs can't be that sure. */
@@ -4237,7 +4388,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`));
+	const tide = tideForecast(project, tasks, parseIso(`${today}T12:00:00`), { reflections: data.reflections });
 	if (tide.kind === "no-pace") return {
 		text: "No forecast yet: nothing finished in the last few weeks",
 		late: false
@@ -7282,18 +7433,21 @@ init_format();
 init_raid();
 init_work();
 init_clock();
+init_soundings();
 const KIND_RANK = {
 	waiting: 0,
 	approval: 1,
 	review: 2,
-	assigned: 3,
-	idle: 4,
-	mention: 5
+	sounding: 3,
+	assigned: 4,
+	idle: 5,
+	mention: 6
 };
 const PING_KIND_LABEL = {
 	waiting: "Waiting on you",
 	approval: "Sign-offs",
 	review: "Reviews due",
+	sounding: "Soundings",
 	assigned: "Assigned to you",
 	idle: "Quiet blockers",
 	mention: "Mentions"
@@ -7424,6 +7578,22 @@ function inboxOf(data, personId, now = clockNow()) {
 			personId
 		});
 	}
+	for (const task of soundingsWaitingOn(data, personId, now)) {
+		const s = task.sounding;
+		if (s.askedById === personId) continue;
+		const by = data.people.find((p) => p.id === s.askedById);
+		const project = projectOf(data, task);
+		pings.push({
+			id: `sounding:${task.id}:${s.askedAt}`,
+			kind: "sounding",
+			title: `${by ? firstName(by.name) : "Someone"} asked how long a task will take`,
+			detail: `“${task.title}”${project ? ` · ${project.name}` : ""} · answer alone; the guesses show together`,
+			at: s.askedAt,
+			taskId: task.id,
+			personId: s.askedById,
+			href: `/projects/${task.projectId}`
+		});
+	}
 	for (const comment of mentionsFor(data.comments, personId)) {
 		const task = data.tasks.find((t) => t.id === comment.taskId);
 		if (!task || task.status === "done") continue;
@@ -10698,12 +10868,103 @@ function PortfolioView({ portfolioId, active, width, height, go, onBack }) {
 	});
 }
 
+//#endregion
+//#region src/lib/fog.ts
+function latestBy(cache, items, key, at) {
+	const hit = cache.get(items);
+	if (hit && hit.size === items.length) return hit.value;
+	const value = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const when = at(item);
+		if (!when) continue;
+		const k = key(item);
+		const had = value.get(k);
+		if (!had || when > had) value.set(k, when);
+	}
+	cache.set(items, {
+		size: items.length,
+		value
+	});
+	return value;
+}
+/** Each task's newest comment, built once per comments list. */
+function latestComments(comments) {
+	return latestBy(commentCache, comments, (c) => c.taskId, (c) => c.editedAt && c.editedAt > c.createdAt ? c.editedAt : c.createdAt);
+}
+function latestFiles(files) {
+	return latestBy(fileCache, files, (a) => a.taskId, (a) => a.addedAt);
+}
+/** When anyone last did anything with this task (an ISO time). */
+function lastTouch(task, data) {
+	let last = task.createdAt;
+	const bump = (at) => {
+		if (at && at > last) last = at;
+	};
+	bump(task.touchedAt);
+	bump(task.assignedAt);
+	bump(task.completedAt);
+	bump(task.github?.[0]?.at);
+	bump(latestComments(data.comments).get(task.id));
+	bump(latestFiles(data.attachments ?? []).get(task.id));
+	return last;
+}
+/** Whole days since the task was last touched, as of `today` (yyyy-MM-dd). */
+function daysUntouched(task, data, today) {
+	const last = parseIso(lastTouch(task, data));
+	if (Number.isNaN(last.getTime())) return 0;
+	return Math.max(0, differenceInCalendarDays(parseIso(today), last));
+}
+function fogLevel(days) {
+	if (days >= 35) return "thick";
+	if (days >= 21) return "fog";
+	return "clear";
+}
+/** "untouched 5 weeks", "untouched 3 weeks". */
+function untouchedText(days) {
+	const weeks = Math.floor(days / 7);
+	if (weeks >= 1) return `untouched ${weeks} week${weeks === 1 ? "" : "s"}`;
+	return `untouched ${days} day${days === 1 ? "" : "s"}`;
+}
+/**
+* The open tasks in fog, longest untouched first. `projectIds` narrows it
+* to some projects; leave it out for the whole harbor.
+*/
+function foggyTasks(data, today, projectIds) {
+	const out = [];
+	for (const task of data.tasks) {
+		if (task.status === "done") continue;
+		if (projectIds && !projectIds.has(task.projectId)) continue;
+		const days = daysUntouched(task, data, today);
+		const level = fogLevel(days);
+		if (level !== "clear") out.push({
+			task,
+			days,
+			level
+		});
+	}
+	return out.sort((a, b) => b.days - a.days);
+}
+/** Whether opening this task should count as touching it: only when it is in fog. */
+function isFoggy(task, data, today) {
+	return task.status !== "done" && daysUntouched(task, data, today) >= 21;
+}
+var FOG_DAYS, THICK_FOG_DAYS, commentCache, fileCache;
+var init_fog = __esmMin((() => {
+	init_date_fns();
+	init_date_text();
+	FOG_DAYS = 21;
+	THICK_FOG_DAYS = 35;
+	commentCache = /* @__PURE__ */ new WeakMap();
+	fileCache = /* @__PURE__ */ new WeakMap();
+}));
+
 //#endregion
 //#region src/tui/views/project.tsx
 init_swatches();
 init_format();
 init_hill();
 init_clock();
+init_fog();
 /** One project: its board (columns side by side) or its list, and the keys to work it. */
 function ProjectView({ projectId, active, width, height, go, onBack }) {
 	const { store, today } = useDeps();
@@ -10714,6 +10975,8 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 	const reflections = useHarbor((s) => s.reflections);
 	const milestones = useHarbor((s) => s.milestones);
 	const raidItems = useHarbor((s) => s.raidItems);
+	const comments = useHarbor((s) => s.comments);
+	const attachments = useHarbor((s) => s.attachments);
 	const project = projects.find((p) => p.id === projectId);
 	const data = useMemo(() => ({
 		tasks,
@@ -10748,6 +11011,14 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 	const [rowByCol, setRowByCol] = useState({});
 	const [listAt, setListAt] = useState(0);
 	const day = today();
+	const fogWeeks = (t) => {
+		if (t.status === "done") return null;
+		const days = daysUntouched(t, {
+			comments,
+			attachments
+		}, day);
+		return days >= 21 ? Math.floor(days / 7) : null;
+	};
 	const column = columns[Math.min(col, columns.length - 1)];
 	const row = Math.min(rowByCol[col] ?? 0, Math.max(0, (column?.tasks.length ?? 1) - 1));
 	const selected = mode === "board" ? column?.tasks[row] : list[Math.min(listAt, list.length - 1)];
@@ -11042,7 +11313,8 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 								late: isLate(t, day),
 								waits: blocked(data, t),
 								priority: t.priority,
-								selected: on && view.start + i === r
+								selected: on && view.start + i === r,
+								fog: fogWeeks(t)
 							}, t.id)),
 							view.start + view.items.length < c.tasks.length ? /* @__PURE__ */ jsxs(Text, {
 								color: theme.muted,
@@ -11083,7 +11355,7 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 	});
 }
 /** One card on the board: its key, due date and owner, then the title on up to two lines. */
-function Card({ taskKey, title, owner, due, late, waits, priority, selected }) {
+function Card({ taskKey, title, owner, due, late, waits, priority, selected, fog = null }) {
 	return /* @__PURE__ */ jsxs(Box, {
 		flexDirection: "column",
 		height: 3,
@@ -11109,6 +11381,14 @@ function Card({ taskKey, title, owner, due, late, waits, priority, selected }) {
 				owner ? /* @__PURE__ */ jsxs(Text, {
 					color: selected ? void 0 : theme.muted,
 					children: [" ", owner]
+				}) : null,
+				fog != null ? /* @__PURE__ */ jsxs(Text, {
+					color: selected ? void 0 : theme.muted,
+					children: [
+						" ░ ",
+						fog,
+						"w"
+					]
 				}) : null
 			]
 		}), /* @__PURE__ */ jsx(Box, {
@@ -11116,7 +11396,8 @@ function Card({ taskKey, title, owner, due, late, waits, priority, selected }) {
 			children: /* @__PURE__ */ jsx(Text, {
 				wrap: "wrap",
 				bold: selected,
-				color: selected ? theme.selected : void 0,
+				dimColor: fog != null && !selected,
+				color: selected ? theme.selected : fog != null ? theme.muted : void 0,
 				children: title
 			})
 		})]
@@ -12615,6 +12896,7 @@ function App({ ui }) {
 	};
 	const go = {
 		openTask: (id) => {
+			store.getState().selectTask(id);
 			setPanel({
 				kind: "task",
 				id
@@ -13268,16 +13550,6 @@ function fieldChange(prev, row) {
 		was
 	};
 }
-/**
-* Apply changes to the rows stored now. A set writes only its own fields,
-* so it keeps whatever someone else changed in the others. `clashIds` names
-* rows where someone else had already changed one of the same fields or had
-* removed the row (the change is dropped); `clashes` says which field and
-* what each side had. By default this change wins a clashed field, as the
-* later save; with `keepTheirs` the stored value stays (undo uses this, so
-* it never takes back someone else's newer edit). Rows nothing touched keep
-* their object.
-*/
 function applyRowChanges(rows, changes, options = {}) {
 	if (changes.length === 0) return {
 		rows: rows.slice(),
@@ -13309,6 +13581,11 @@ function applyRowChanges(rows, changes, options = {}) {
 		const fields = {};
 		let clashed = false;
 		for (const [key, value] of Object.entries(change.fields)) {
+			if (LATEST_WINS.has(key)) {
+				const had = stored[key];
+				if (typeof had !== "string" || typeof value === "string" && value > had) fields[key] = value;
+				continue;
+			}
 			if (!deepEqual(stored[key], was[key]) && !deepEqual(stored[key], value)) {
 				clashed = true;
 				clashes.push({
@@ -13339,8 +13616,10 @@ function applyRowChanges(rows, changes, options = {}) {
 		clashes
 	};
 }
+var LATEST_WINS;
 var init_row_changes = __esmMin((() => {
 	init_deep_equal();
+	LATEST_WINS = /* @__PURE__ */ new Set(["touchedAt"]);
 }));
 
 //#endregion
@@ -13546,7 +13825,8 @@ function withStatus(task, status) {
 	if (task.status === status) return task;
 	const next = {
 		...task,
-		status
+		status,
+		touchedAt: stamp()
 	};
 	if (status === "done") next.completedAt = stamp();
 	else if (task.status === "done") next.completedAt = null;
@@ -13659,6 +13939,14 @@ function sessionSlice({ set, get, write }) {
 		selectTask: (id) => {
 			if (get().selectedTaskId === id) return;
 			set({ selectedTaskId: id });
+			const task = id ? get().tasks.find((t) => t.id === id) : void 0;
+			if (task && !readOnlyHarbor(get()) && isFoggy(task, get(), todayISO())) {
+				const at = stamp();
+				set({ tasks: get().tasks.map((t) => t.id === id ? {
+					...t,
+					touchedAt: at
+				} : t) });
+			}
 		},
 		log: (text, href) => {
 			if (readOnlyHarbor(get())) return;
@@ -13711,6 +13999,8 @@ var init_session = __esmMin((() => {
 	init_shared();
 	init_undo_state();
 	init_view_only();
+	init_fog();
+	init_format();
 }));
 
 //#endregion
@@ -14486,7 +14776,8 @@ function tasksSlice({ set, get, write }) {
 				if (row.id !== id) return row;
 				const next = {
 					...row,
-					...patch
+					...patch,
+					touchedAt: stamp()
 				};
 				if (patch.status && patch.status !== row.status) {
 					if (patch.status === "done" && !patch.completedAt) next.completedAt = stamp();
@@ -14637,6 +14928,7 @@ function tasksSlice({ set, get, write }) {
 			if (!name) return;
 			set({ tasks: get().tasks.map((t) => t.id === taskId ? {
 				...t,
+				touchedAt: stamp(),
 				checklist: [...t.checklist ?? [], {
 					id: uid("ch"),
 					title: name,
@@ -14647,6 +14939,7 @@ function tasksSlice({ set, get, write }) {
 		toggleChecklistItem: (taskId, itemId) => {
 			set({ tasks: get().tasks.map((t) => t.id === taskId ? {
 				...t,
+				touchedAt: stamp(),
 				checklist: (t.checklist ?? []).map((i) => i.id === itemId ? {
 					...i,
 					done: !i.done
@@ -14656,6 +14949,7 @@ function tasksSlice({ set, get, write }) {
 		removeChecklistItem: (taskId, itemId) => {
 			set({ tasks: get().tasks.map((t) => t.id === taskId ? {
 				...t,
+				touchedAt: stamp(),
 				checklist: (t.checklist ?? []).filter((i) => i.id !== itemId)
 			} : t) });
 		},
@@ -14680,6 +14974,7 @@ function tasksSlice({ set, get, write }) {
 		setTaskCustomFieldValue: (taskId, fieldId, value) => {
 			write({ tasks: get().tasks.map((t) => t.id === taskId ? {
 				...t,
+				touchedAt: stamp(),
 				customFieldValues: {
 					...t.customFieldValues ?? {},
 					[fieldId]: value
@@ -14711,6 +15006,17 @@ function tasksSlice({ set, get, write }) {
 			write({ tasks: get().tasks.map((t) => tick.has(t.id) && t.status !== "done" ? withStatus(t, "done") : t) });
 			for (const t of ticked) get().log(`ticked off “${t.title}” on First voyage`, `/projects/${t.projectId}`);
 		},
+		keepTasks: (ids) => {
+			const keep = new Set(ids);
+			const kept = get().tasks.filter((t) => keep.has(t.id));
+			if (kept.length === 0) return;
+			const at = stamp();
+			write({ tasks: get().tasks.map((t) => keep.has(t.id) ? {
+				...t,
+				touchedAt: at
+			} : t) });
+			get().log(kept.length === 1 ? `kept “${kept[0].title}” out of the fog` : `kept ${kept.length} tasks out of the fog`, kept.length === 1 ? `/projects/${kept[0].projectId}` : void 0);
+		},
 		toggleFocus: (taskId) => {
 			const personId = get().currentUserId;
 			const date = todayISO();
@@ -14722,8 +15028,83 @@ function tasksSlice({ set, get, write }) {
 			if (ids.length >= 3) return "full";
 			set({ ropes: upsertFocus(get().ropes, personId, date, [...ids, taskId]) });
 			return "added";
+		},
+		takeSounding: (taskId, crewIds) => {
+			const s = get();
+			const task = s.tasks.find((t) => t.id === taskId);
+			const people = new Set(s.people.filter((p) => p.kind !== "agent").map((p) => p.id));
+			const crew = [...new Set(crewIds)].filter((id) => people.has(id)).slice(0, 12);
+			if (!task || task.status === "done" || crew.length === 0) return false;
+			const sounding = {
+				askedAt: clockNow().toISOString(),
+				askedById: s.currentUserId,
+				crewIds: crew
+			};
+			set({
+				tasks: s.tasks.map((t) => t.id === taskId ? {
+					...t,
+					sounding
+				} : t),
+				reflections: (s.reflections ?? []).filter((r) => !(r.kind === "sounding" && r.taskId === taskId))
+			});
+			return true;
+		},
+		answerSounding: (taskId, days, why = "") => {
+			const s = get();
+			const task = s.tasks.find((t) => t.id === taskId);
+			if (!task?.sounding || !task.sounding.crewIds.includes(s.currentUserId)) return false;
+			if (daysProblem(days)) return false;
+			const me = s.currentUserId;
+			const others = (s.reflections ?? []).filter((r) => !(r.kind === "sounding" && r.taskId === taskId && r.authorId === me));
+			const row = {
+				id: uid("rf"),
+				projectId: task.projectId,
+				kind: "sounding",
+				authorId: me,
+				body: why.trim().slice(0, 300),
+				createdAt: clockNow().toISOString(),
+				taskId,
+				days
+			};
+			set({ reflections: [...others, row] });
+			return true;
+		},
+		showSounding: (taskId) => {
+			const task = get().tasks.find((t) => t.id === taskId);
+			if (!task?.sounding || task.sounding.shownAt) return;
+			setSounding(taskId, {
+				...task.sounding,
+				shownAt: clockNow().toISOString()
+			});
+		},
+		settleSounding: (taskId, days) => {
+			const task = get().tasks.find((t) => t.id === taskId);
+			if (!task?.sounding) return false;
+			if (days !== null && daysProblem(days)) return false;
+			setSounding(taskId, {
+				...task.sounding,
+				settledDays: days
+			});
+			return true;
+		},
+		stopSounding: (taskId) => {
+			const s = get();
+			if (!s.tasks.some((t) => t.id === taskId && t.sounding)) return;
+			set({
+				tasks: s.tasks.map((t) => t.id === taskId ? {
+					...t,
+					sounding: null
+				} : t),
+				reflections: (s.reflections ?? []).filter((r) => !(r.kind === "sounding" && r.taskId === taskId))
+			});
 		}
 	};
+	function setSounding(taskId, sounding) {
+		set({ tasks: get().tasks.map((t) => t.id === taskId ? {
+			...t,
+			sounding
+		} : t) });
+	}
 }
 var init_tasks = __esmMin((() => {
 	init_github_refs();
@@ -14731,6 +15112,8 @@ var init_tasks = __esmMin((() => {
 	init_automations();
 	init_focus();
 	init_format();
+	init_soundings();
+	init_clock();
 	init_utils();
 	init_blockers();
 	init_work();
@@ -16501,356 +16884,149 @@ async function pickHarbor(deps) {
 }
 
 //#endregion
-//#region src/repo/plan-files.ts
-/** "RR-42.md" → "RR-42"; a file named anything else is a new task. */
-function keyOfFile(name) {
-	return KEY_NAME.exec(name)?.[1] ?? null;
-}
-/** A front-matter value written so it reads back the same. */
-function scalar(value) {
-	return value === value.trim() && value !== "" && !/^["'[\]{}>|*&!%@#`,?:-]/.test(value) && !/: |\s#/.test(value) && !/^(null|~|true|false|yes|no|-?\d[\d.]*)$/i.test(value) ? value : JSON.stringify(value);
-}
-function unquote(raw) {
-	const v = raw.trim();
-	if (v.startsWith("\"") && v.endsWith("\"") && v.length > 1) try {
-		return String(JSON.parse(v));
-	} catch {
-		return v.slice(1, -1);
+//#region src/lib/command-line.ts
+init_date_fns();
+init_format();
+const PAGES = {
+	today: "/today",
+	inbox: "/inbox",
+	brief: "/brief",
+	review: "/review",
+	portfolios: "/portfolios",
+	programs: "/programs",
+	projects: "/projects",
+	risks: "/risks",
+	calendar: "/calendar",
+	people: "/people"
+};
+const HELP = [
+	{ text: "add \"TITLE\" [#project] [@person] [--due fri|+3|2026-11-02]" },
+	{ text: "mine                    what's on you, late first" },
+	{ text: "tasks [words] [--late] [#project] [@person]" },
+	{ text: "show RR-12             open a task" },
+	{ text: "start | review | done RR-12" },
+	{ text: "comment RR-12 \"TEXT\"" },
+	{ text: "checkin \"WHAT YOU'RE ON\" [--on-blocker]" },
+	{ text: `go ${Object.keys(PAGES).join("|")}` },
+	{
+		text: "undo · clear · help",
+		tone: "muted"
 	}
-	if (v.startsWith("'") && v.endsWith("'") && v.length > 1) return v.slice(1, -1).replace(/''/g, "'");
-	return v;
-}
-function list$1(raw) {
-	const v = raw.trim();
-	return (v.startsWith("[") && v.endsWith("]") ? v.slice(1, -1) : v).split(",").map((x) => unquote(x)).filter(Boolean);
-}
-/** A task's file, as `harbor sync` writes it. */
-function renderTask(f) {
-	const lines = [
-		"---",
-		`title: ${scalar(f.title)}`,
-		`status: ${f.status}`,
-		`owner: ${f.owner ? scalar(f.owner) : ""}`.trimEnd(),
-		`due: ${f.due ?? ""}`.trimEnd(),
-		`priority: ${f.priority}`
-	];
-	if (f.waits.length) lines.push(`waits: [${f.waits.join(", ")}]`);
-	if (f.repeat) lines.push(`repeat: ${f.repeat}`);
-	lines.push("---");
-	const notes = f.notes.trim();
-	return `${lines.join("\n")}\n${notes ? `${notes}\n` : ""}`;
+];
+var CommandError = class extends Error {};
+const WEEKDAYS = [
+	"sun",
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat"
+];
+/** today, tomorrow, +N, a weekday (the next one, never today) or YYYY-MM-DD. */
+function dueFrom(value, now) {
+	const v = value.trim().toLowerCase();
+	if (v === "today") return todayISO(now);
+	if (v === "tomorrow") return todayISO(addDays(now, 1));
+	if (/^\+\d{1,3}$/.test(v)) return todayISO(addDays(now, Number(v.slice(1))));
+	const day = WEEKDAYS.findIndex((d) => v.startsWith(d) && d.length >= 3 && v.length >= 3);
+	if (day >= 0) {
+		const ahead = (day - now.getDay() + 7) % 7 || 7;
+		return todayISO(addDays(now, ahead));
+	}
+	if (/^\d{4}-\d{2}-\d{2}$/.test(v) && !Number.isNaN(parseDate$1(v).getTime())) return v;
+	throw new CommandError(`Can't read the date "${value}". Try today, fri, +3 or 2026-11-02.`);
 }
+
+//#endregion
+//#region src/tui/fog-sweep.ts
 /**
-* A task's file read back. Missing fields take their empty value (no owner,
-* no due date, medium priority), so deleting a line clears it. Anything it
-* can't read is named in `problems`, and a file without a title isn't a task.
+* `harbor fog` in a terminal: the tasks nobody has touched for three weeks
+* (lib/fog.ts), one at a time, on the store's own actions. k keeps it
+* (clears the fog), d asks for a new date, x drops it, s skips, q stops.
+* The CLI saves through the sync loop afterwards.
 */
-function parseTask(text) {
-	const problems = [];
-	const src = text.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
-	const fm = /^---\n([\s\S]*?)\n---(?:\n|$)([\s\S]*)$/.exec(src);
-	if (!fm) return {
-		fields: null,
-		problems: ["it doesn't start with a --- block"]
-	};
-	const values = /* @__PURE__ */ new Map();
-	const lists = /* @__PURE__ */ new Map();
-	let open = null;
-	for (const line of fm[1].split("\n")) {
-		if (!line.trim() || line.trim().startsWith("#")) continue;
-		const item = /^\s+-\s*(.*)$/.exec(line);
-		if (item && open) {
-			lists.get(open).push(unquote(item[1]));
-			continue;
-		}
-		const kv = /^([A-Za-z][\w-]*)\s*:\s?(.*)$/.exec(line);
-		if (!kv) {
-			problems.push(`couldn't read "${line.trim()}"`);
-			continue;
+init_fog();
+const plural$2 = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+async function sweepFog(opts) {
+	const { store, ask, say, today } = opts;
+	const start = store.getState();
+	const queue = foggyTasks(start, today, opts.projectId ? /* @__PURE__ */ new Set([opts.projectId]) : void 0);
+	const tally = {
+		foggy: queue.length,
+		kept: 0,
+		dated: 0,
+		dropped: 0,
+		skipped: 0
+	};
+	if (queue.length === 0) {
+		say("No fog: every open task was touched in the last three weeks.");
+		return tally;
+	}
+	say(`Clear the fog · ${plural$2(queue.length, "task")} nobody has opened, moved or commented on for three weeks.`);
+	say("k still needed   d new date   x drop it   s skip   q stop\n");
+	let stopped = false;
+	for (let i = 0; i < queue.length && !stopped; i++) {
+		const { task, days } = queue[i];
+		const s = store.getState();
+		if (!s.tasks.some((t) => t.id === task.id)) continue;
+		const project = s.projects.find((p) => p.id === task.projectId);
+		const where = [
+			keyOf$1(s, task),
+			opts.projectId ? null : project?.name,
+			untouchedText(days),
+			task.dueDate ? `due ${shortDay(task.dueDate, today)}` : null
+		].filter(Boolean).join(" · ");
+		say(`${i + 1} of ${queue.length}  ${task.title}`);
+		say(`  ${where}`);
+		for (;;) {
+			const key = (await ask("  k, d, x, s or q: ")).trim().toLowerCase();
+			if (key === "k") {
+				store.getState().keepTasks([task.id]);
+				tally.kept++;
+				say("  Kept. The fog's off it.\n");
+			} else if (key === "d") {
+				let due = null;
+				while (!due) {
+					const typed = (await ask("  New due date (today, fri, +7, YYYY-MM-DD): ")).trim();
+					if (!typed) break;
+					try {
+						due = dueFrom(typed, opts.now);
+					} catch (err) {
+						say(`  ${err.message}`);
+					}
+				}
+				if (!due) continue;
+				store.getState().updateTask(task.id, { dueDate: due });
+				tally.dated++;
+				say(`  Due ${shortDay(due, today)} now.\n`);
+			} else if (key === "x") {
+				store.getState().deleteTask(task.id);
+				tally.dropped++;
+				say("  Dropped.\n");
+			} else if (key === "s" || key === "") {
+				tally.skipped++;
+				say("  Left for next time.\n");
+			} else if (key === "q") stopped = true;
+			else continue;
+			break;
 		}
-		const key = kv[1].toLowerCase();
-		values.set(key, kv[2]);
-		open = kv[2].trim() === "" ? key : null;
-		if (open) lists.set(open, []);
-	}
-	const value = (k) => {
-		const block = lists.get(k);
-		if (block && block.length) return block.join(", ");
-		return unquote(values.get(k) ?? "");
-	};
-	const title = value("title");
-	if (!title) return {
-		fields: null,
-		problems: [...problems, "it has no title"]
-	};
-	const statusText = value("status").toLowerCase();
-	const status = statusText ? STATUS_WORDS[statusText] : "todo";
-	if (!status) problems.push(`status "${statusText}" isn't one of backlog, todo, doing, review, done`);
-	const priorityText = value("priority").toLowerCase();
-	const priority = priorityText ? PRIORITIES.find((p) => p === priorityText) : "medium";
-	if (!priority) problems.push(`priority "${priorityText}" isn't low, medium, high or urgent`);
-	const due = value("due") || null;
-	const dueOk = !due || /^\d{4}-\d{2}-\d{2}$/.test(due) && !Number.isNaN(Date.parse(due));
-	if (!dueOk) problems.push(`due "${due}" isn't a date like 2026-11-07`);
-	const repeatText = value("repeat").toLowerCase();
-	const repeat = !repeatText || repeatText === "never" ? null : REPEATS.find((r) => r === repeatText) ?? null;
-	if (repeatText && repeatText !== "never" && !repeat) problems.push(`repeat "${repeatText}" isn't weekly, biweekly or monthly`);
-	const waits = (lists.get("waits")?.length ? lists.get("waits") : list$1(values.get("waits") ?? "")).map((k) => k.toUpperCase());
-	return {
-		fields: {
-			title,
-			status: status ?? "todo",
-			owner: value("owner") || null,
-			due: dueOk ? due : null,
-			priority: priority ?? "medium",
-			waits,
-			repeat,
-			notes: fm[2].trim()
-		},
-		problems
-	};
-}
-/** The key a task goes by in this harbor, like RR-42. */
-function keyOf(data, task) {
-	return taskKey(task, data.projects.find((p) => p.id === task.projectId));
-}
-/** What a task's file says, read off the harbor. */
-function fieldsOf(data, task) {
-	const people = byId(data.people);
-	const tasks = byId(data.tasks);
-	const waitIds = task.blockedByIds ?? (task.blockedById ? [task.blockedById] : []);
-	return {
-		title: task.title,
-		status: task.status,
-		owner: task.assigneeId ? people.get(task.assigneeId)?.name ?? null : null,
-		due: task.dueDate,
-		priority: task.priority,
-		waits: waitIds.map((id) => tasks.get(id)).map((t) => t ? keyOf(data, t) : null).filter((k) => Boolean(k)),
-		repeat: task.repeat ?? null,
-		notes: task.description.trim()
-	};
-}
-/** The person a file's owner names: their whole name, else a first name or initials only they have. */
-function personNamed$1(people, name) {
-	const want = name.trim().toLowerCase();
-	if (!want) return null;
-	const exact = people.filter((p) => p.name.trim().toLowerCase() === want);
-	if (exact.length === 1) return exact[0];
-	const first = people.filter((p) => p.name.trim().toLowerCase().split(/\s+/)[0] === want);
-	if (first.length === 1) return first[0];
-	const initials = people.filter((p) => p.initials.toLowerCase() === want);
-	return initials.length === 1 ? initials[0] : null;
-}
-/**
-* The folder's changes to one task, worked out against the base: a field
-* the file changed and the harbor didn't goes to the harbor; one both
-* changed differently stays as the harbor has it, and is named.
-*/
-function mergeTask(base, file, harbor) {
-	const patch = {};
-	const clashes = [];
-	for (const k of FIELDS) {
-		if (same(file[k], base[k]) || same(file[k], harbor[k])) continue;
-		if (same(harbor[k], base[k])) patch[k] = file[k];
-		else clashes.push({
-			field: k,
-			file: shown(file[k]),
-			harbor: shown(harbor[k])
-		});
-	}
-	return {
-		patch,
-		clashes
-	};
-}
-/** What a set of file fields means as a change to a task in this harbor. */
-function taskPatch(data, fields, say, label) {
-	const patch = {};
-	if (fields.title !== void 0) patch.title = fields.title;
-	if (fields.status !== void 0) patch.status = fields.status;
-	if (fields.due !== void 0) patch.dueDate = fields.due;
-	if (fields.priority !== void 0) patch.priority = fields.priority;
-	if (fields.repeat !== void 0) patch.repeat = fields.repeat;
-	if (fields.notes !== void 0) patch.description = fields.notes;
-	if (fields.owner !== void 0) {
-		const person = fields.owner ? personNamed$1(data.people, fields.owner) : null;
-		if (fields.owner && !person) say(`${label}: nobody called "${fields.owner}" is in the harbor, so it has no owner.`);
-		patch.assigneeId = person?.id ?? null;
-	}
-	if (fields.waits !== void 0) {
-		const ids = [];
-		for (const key of fields.waits) {
-			const t = findByKey(data, key);
-			if (t) ids.push(t.id);
-			else say(`${label}: there's no ${key} to wait on, so that was left out.`);
-		}
-		patch.blockedByIds = ids;
-		patch.blockedById = ids[0] ?? null;
-	}
-	return patch;
-}
-/** The base: what each of a project's tasks said when the folder last matched the harbor. */
-function baseOf(data, projectId) {
-	const base = {};
-	for (const t of data.tasks) if (t.projectId === projectId) base[t.id] = fieldsOf(data, t);
-	return base;
-}
-/** A person a local plan adds for an owner it hasn't met. */
-function localPerson(name, id) {
-	return {
-		id,
-		name,
-		role: "Crew",
-		initials: initialsOf(name),
-		swatch: "pine",
-		location: ""
-	};
-}
-/** `.harbor/README.md`: what the folder is, for whoever finds it in the repository. */
-function readme(config) {
-	return `# Plan
-
-The tasks for this repository, one file per task in \`tasks/\`, kept by [Harbor](https://harborppm.com/ai). ${config.local ? "This plan lives only in this folder. Run `harbor` here to open it full screen; `harbor init PROJECT` later keeps it in step with a project on harborppm.com." : `It's kept in step with the ${config.project.name} project on harborppm.com: run \`harbor sync\` after editing, or after pulling, to bring both up to date.`}
-
-Each file has its fields between the \`---\` lines and its notes below:
-
-\`\`\`md
----
-title: Move checkout to the new API
-status: doing
-owner: Sam Rivera
-due: 2026-11-07
-priority: high
-waits: [${config.project.key}-2]
----
-Old endpoints go away on Nov 20.
-\`\`\`
-
-- status: backlog, todo, doing, review or done
-- priority: low, medium, high or urgent
-- repeat (optional): weekly, biweekly or monthly
-- A new file with any name is a new task; Harbor gives it a key and renames it.
-- Removing a file doesn't remove the task. Mark it done instead.
-`;
-}
-var FIELDS, TASKS_DIR, CONFIG_FILE, BASE_FILE, LOCAL_FILE, STATUS_WORDS, PRIORITIES, REPEATS, KEY_NAME, same, shown;
-var init_plan_files = __esmMin((() => {
-	init_shared();
-	init_indexes();
-	init_task_keys();
-	FIELDS = [
-		"title",
-		"status",
-		"owner",
-		"due",
-		"priority",
-		"waits",
-		"repeat",
-		"notes"
-	];
-	TASKS_DIR = "tasks";
-	CONFIG_FILE = "harbor.json";
-	BASE_FILE = "state/base.json";
-	LOCAL_FILE = "plan.json";
-	STATUS_WORDS = {
-		backlog: "backlog",
-		todo: "todo",
-		"to-do": "todo",
-		"to do": "todo",
-		doing: "doing",
-		"in-progress": "doing",
-		"in progress": "doing",
-		started: "doing",
-		review: "review",
-		"in-review": "review",
-		"in review": "review",
-		done: "done",
-		finished: "done"
-	};
-	PRIORITIES = [
-		"low",
-		"medium",
-		"high",
-		"urgent"
-	];
-	REPEATS = [
-		"weekly",
-		"biweekly",
-		"monthly"
-	];
-	KEY_NAME = /^([A-Z][A-Z0-9]{0,9}-\d{1,7})\.md$/;
-	same = (a, b) => Array.isArray(a) && Array.isArray(b) ? a.join(",") === b.join(",") : a === b;
-	shown = (v) => Array.isArray(v) ? v.join(", ") || "nothing" : v === null || v === "" ? "nothing" : String(v);
-}));
-
-//#endregion
-//#region src/repo/folder.ts
-/**
-* The `.harbor/` folder on disk, and finding it: like git, `harbor sync`
-* works from anywhere inside the repository.
-*/
-function diskFolder(root) {
-	return {
-		async read(path) {
-			try {
-				return await readFile(join(root, path), "utf8");
-			} catch (error) {
-				if (error.code === "ENOENT") return null;
-				throw error;
-			}
-		},
-		async write(path, text) {
-			const file = join(root, path);
-			await mkdir(dirname(file), { recursive: true });
-			const temp = `${file}.${process.pid}.tmp`;
-			await writeFile(temp, text);
-			await rename(temp, file);
-		},
-		async remove(path) {
-			await rm(join(root, path), { force: true });
-		},
-		async list(dir) {
-			try {
-				return (await readdir(join(root, dir), { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
-			} catch (error) {
-				if (error.code === "ENOENT") return [];
-				throw error;
-			}
-		}
-	};
-}
-/** The nearest `.harbor/` with a plan in it, from `start` up; null when there's none. */
-async function findPlan(start) {
-	let dir = resolve(start);
-	for (;;) {
-		const here = join(dir, PLAN_DIR);
-		try {
-			await readFile(join(here, CONFIG_FILE));
-			return here;
-		} catch {}
-		const up = dirname(dir);
-		if (up === dir) return null;
-		dir = up;
 	}
+	say(fogSummary(tally));
+	return tally;
 }
-/** Where a new plan goes: the repository's top (the folder holding .git), else here. */
-async function planHome(start) {
-	let dir = resolve(start);
-	for (;;) {
-		try {
-			await access(join(dir, ".git"));
-			return dir;
-		} catch {}
-		const up = dirname(dir);
-		if (up === dir) return resolve(start);
-		dir = up;
-	}
+/** "2 still needed, 1 given a new date, 1 dropped." */
+function fogSummary(t) {
+	const parts = [
+		t.kept && `${t.kept} still needed`,
+		t.dated && `${t.dated} given a new date`,
+		t.dropped && `${t.dropped} dropped`,
+		t.skipped && `${t.skipped} left for next time`
+	].filter(Boolean);
+	const left = t.foggy - t.kept - t.dated - t.dropped - t.skipped;
+	if (left > 0) parts.push(`${left} not looked at`);
+	return parts.length ? `${parts.join(", ")}.` : "Nothing changed.";
 }
-var PLAN_DIR;
-var init_folder = __esmMin((() => {
-	init_plan_files();
-	PLAN_DIR = ".harbor";
-}));
 
 //#endregion
 //#region src/tui/engine/memory-crew.ts
@@ -17188,14 +17364,297 @@ function memoryHarbor(start, opts) {
 		}
 	};
 }
-var init_memory = __esmMin((() => {
-	init_changes();
-	init_live_changes();
-	init_row_changes();
-	init_task_keys();
+var init_memory = __esmMin((() => {
+	init_changes();
+	init_live_changes();
+	init_row_changes();
+	init_task_keys();
+	init_indexes();
+	init_memory_crew();
+	init_transport();
+}));
+
+//#endregion
+//#region src/repo/plan-files.ts
+/** "RR-42.md" → "RR-42"; a file named anything else is a new task. */
+function keyOfFile(name) {
+	return KEY_NAME.exec(name)?.[1] ?? null;
+}
+/** A front-matter value written so it reads back the same. */
+function scalar(value) {
+	return value === value.trim() && value !== "" && !/^["'[\]{}>|*&!%@#`,?:-]/.test(value) && !/: |\s#/.test(value) && !/^(null|~|true|false|yes|no|-?\d[\d.]*)$/i.test(value) ? value : JSON.stringify(value);
+}
+function unquote(raw) {
+	const v = raw.trim();
+	if (v.startsWith("\"") && v.endsWith("\"") && v.length > 1) try {
+		return String(JSON.parse(v));
+	} catch {
+		return v.slice(1, -1);
+	}
+	if (v.startsWith("'") && v.endsWith("'") && v.length > 1) return v.slice(1, -1).replace(/''/g, "'");
+	return v;
+}
+function list$1(raw) {
+	const v = raw.trim();
+	return (v.startsWith("[") && v.endsWith("]") ? v.slice(1, -1) : v).split(",").map((x) => unquote(x)).filter(Boolean);
+}
+/** A task's file, as `harbor sync` writes it. */
+function renderTask(f) {
+	const lines = [
+		"---",
+		`title: ${scalar(f.title)}`,
+		`status: ${f.status}`,
+		`owner: ${f.owner ? scalar(f.owner) : ""}`.trimEnd(),
+		`due: ${f.due ?? ""}`.trimEnd(),
+		`priority: ${f.priority}`
+	];
+	if (f.waits.length) lines.push(`waits: [${f.waits.join(", ")}]`);
+	if (f.repeat) lines.push(`repeat: ${f.repeat}`);
+	lines.push("---");
+	const notes = f.notes.trim();
+	return `${lines.join("\n")}\n${notes ? `${notes}\n` : ""}`;
+}
+/**
+* A task's file read back. Missing fields take their empty value (no owner,
+* no due date, medium priority), so deleting a line clears it. Anything it
+* can't read is named in `problems`, and a file without a title isn't a task.
+*/
+function parseTask(text) {
+	const problems = [];
+	const src = text.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+	const fm = /^---\n([\s\S]*?)\n---(?:\n|$)([\s\S]*)$/.exec(src);
+	if (!fm) return {
+		fields: null,
+		problems: ["it doesn't start with a --- block"]
+	};
+	const values = /* @__PURE__ */ new Map();
+	const lists = /* @__PURE__ */ new Map();
+	let open = null;
+	for (const line of fm[1].split("\n")) {
+		if (!line.trim() || line.trim().startsWith("#")) continue;
+		const item = /^\s+-\s*(.*)$/.exec(line);
+		if (item && open) {
+			lists.get(open).push(unquote(item[1]));
+			continue;
+		}
+		const kv = /^([A-Za-z][\w-]*)\s*:\s?(.*)$/.exec(line);
+		if (!kv) {
+			problems.push(`couldn't read "${line.trim()}"`);
+			continue;
+		}
+		const key = kv[1].toLowerCase();
+		values.set(key, kv[2]);
+		open = kv[2].trim() === "" ? key : null;
+		if (open) lists.set(open, []);
+	}
+	const value = (k) => {
+		const block = lists.get(k);
+		if (block && block.length) return block.join(", ");
+		return unquote(values.get(k) ?? "");
+	};
+	const title = value("title");
+	if (!title) return {
+		fields: null,
+		problems: [...problems, "it has no title"]
+	};
+	const statusText = value("status").toLowerCase();
+	const status = statusText ? STATUS_WORDS[statusText] : "todo";
+	if (!status) problems.push(`status "${statusText}" isn't one of backlog, todo, doing, review, done`);
+	const priorityText = value("priority").toLowerCase();
+	const priority = priorityText ? PRIORITIES.find((p) => p === priorityText) : "medium";
+	if (!priority) problems.push(`priority "${priorityText}" isn't low, medium, high or urgent`);
+	const due = value("due") || null;
+	const dueOk = !due || /^\d{4}-\d{2}-\d{2}$/.test(due) && !Number.isNaN(Date.parse(due));
+	if (!dueOk) problems.push(`due "${due}" isn't a date like 2026-11-07`);
+	const repeatText = value("repeat").toLowerCase();
+	const repeat = !repeatText || repeatText === "never" ? null : REPEATS.find((r) => r === repeatText) ?? null;
+	if (repeatText && repeatText !== "never" && !repeat) problems.push(`repeat "${repeatText}" isn't weekly, biweekly or monthly`);
+	const waits = (lists.get("waits")?.length ? lists.get("waits") : list$1(values.get("waits") ?? "")).map((k) => k.toUpperCase());
+	return {
+		fields: {
+			title,
+			status: status ?? "todo",
+			owner: value("owner") || null,
+			due: dueOk ? due : null,
+			priority: priority ?? "medium",
+			waits,
+			repeat,
+			notes: fm[2].trim()
+		},
+		problems
+	};
+}
+/** The key a task goes by in this harbor, like RR-42. */
+function keyOf(data, task) {
+	return taskKey(task, data.projects.find((p) => p.id === task.projectId));
+}
+/** What a task's file says, read off the harbor. */
+function fieldsOf(data, task) {
+	const people = byId(data.people);
+	const tasks = byId(data.tasks);
+	const waitIds = task.blockedByIds ?? (task.blockedById ? [task.blockedById] : []);
+	return {
+		title: task.title,
+		status: task.status,
+		owner: task.assigneeId ? people.get(task.assigneeId)?.name ?? null : null,
+		due: task.dueDate,
+		priority: task.priority,
+		waits: waitIds.map((id) => tasks.get(id)).map((t) => t ? keyOf(data, t) : null).filter((k) => Boolean(k)),
+		repeat: task.repeat ?? null,
+		notes: task.description.trim()
+	};
+}
+/** The person a file's owner names: their whole name, else a first name or initials only they have. */
+function personNamed$1(people, name) {
+	const want = name.trim().toLowerCase();
+	if (!want) return null;
+	const exact = people.filter((p) => p.name.trim().toLowerCase() === want);
+	if (exact.length === 1) return exact[0];
+	const first = people.filter((p) => p.name.trim().toLowerCase().split(/\s+/)[0] === want);
+	if (first.length === 1) return first[0];
+	const initials = people.filter((p) => p.initials.toLowerCase() === want);
+	return initials.length === 1 ? initials[0] : null;
+}
+/**
+* The folder's changes to one task, worked out against the base: a field
+* the file changed and the harbor didn't goes to the harbor; one both
+* changed differently stays as the harbor has it, and is named.
+*/
+function mergeTask(base, file, harbor) {
+	const patch = {};
+	const clashes = [];
+	for (const k of FIELDS) {
+		if (same(file[k], base[k]) || same(file[k], harbor[k])) continue;
+		if (same(harbor[k], base[k])) patch[k] = file[k];
+		else clashes.push({
+			field: k,
+			file: shown(file[k]),
+			harbor: shown(harbor[k])
+		});
+	}
+	return {
+		patch,
+		clashes
+	};
+}
+/** What a set of file fields means as a change to a task in this harbor. */
+function taskPatch(data, fields, say, label) {
+	const patch = {};
+	if (fields.title !== void 0) patch.title = fields.title;
+	if (fields.status !== void 0) patch.status = fields.status;
+	if (fields.due !== void 0) patch.dueDate = fields.due;
+	if (fields.priority !== void 0) patch.priority = fields.priority;
+	if (fields.repeat !== void 0) patch.repeat = fields.repeat;
+	if (fields.notes !== void 0) patch.description = fields.notes;
+	if (fields.owner !== void 0) {
+		const person = fields.owner ? personNamed$1(data.people, fields.owner) : null;
+		if (fields.owner && !person) say(`${label}: nobody called "${fields.owner}" is in the harbor, so it has no owner.`);
+		patch.assigneeId = person?.id ?? null;
+	}
+	if (fields.waits !== void 0) {
+		const ids = [];
+		for (const key of fields.waits) {
+			const t = findByKey(data, key);
+			if (t) ids.push(t.id);
+			else say(`${label}: there's no ${key} to wait on, so that was left out.`);
+		}
+		patch.blockedByIds = ids;
+		patch.blockedById = ids[0] ?? null;
+	}
+	return patch;
+}
+/** The base: what each of a project's tasks said when the folder last matched the harbor. */
+function baseOf(data, projectId) {
+	const base = {};
+	for (const t of data.tasks) if (t.projectId === projectId) base[t.id] = fieldsOf(data, t);
+	return base;
+}
+/** A person a local plan adds for an owner it hasn't met. */
+function localPerson(name, id) {
+	return {
+		id,
+		name,
+		role: "Crew",
+		initials: initialsOf(name),
+		swatch: "pine",
+		location: ""
+	};
+}
+/** `.harbor/README.md`: what the folder is, for whoever finds it in the repository. */
+function readme(config) {
+	return `# Plan
+
+The tasks for this repository, one file per task in \`tasks/\`, kept by [Harbor](https://harborppm.com/ai). ${config.local ? "This plan lives only in this folder. Run `harbor` here to open it full screen; `harbor init PROJECT` later keeps it in step with a project on harborppm.com." : `It's kept in step with the ${config.project.name} project on harborppm.com: run \`harbor sync\` after editing, or after pulling, to bring both up to date.`}
+
+Each file has its fields between the \`---\` lines and its notes below:
+
+\`\`\`md
+---
+title: Move checkout to the new API
+status: doing
+owner: Sam Rivera
+due: 2026-11-07
+priority: high
+waits: [${config.project.key}-2]
+---
+Old endpoints go away on Nov 20.
+\`\`\`
+
+- status: backlog, todo, doing, review or done
+- priority: low, medium, high or urgent
+- repeat (optional): weekly, biweekly or monthly
+- A new file with any name is a new task; Harbor gives it a key and renames it.
+- Removing a file doesn't remove the task. Mark it done instead.
+`;
+}
+var FIELDS, TASKS_DIR, CONFIG_FILE, BASE_FILE, LOCAL_FILE, STATUS_WORDS, PRIORITIES, REPEATS, KEY_NAME, same, shown;
+var init_plan_files = __esmMin((() => {
+	init_shared();
 	init_indexes();
-	init_memory_crew();
-	init_transport();
+	init_task_keys();
+	FIELDS = [
+		"title",
+		"status",
+		"owner",
+		"due",
+		"priority",
+		"waits",
+		"repeat",
+		"notes"
+	];
+	TASKS_DIR = "tasks";
+	CONFIG_FILE = "harbor.json";
+	BASE_FILE = "state/base.json";
+	LOCAL_FILE = "plan.json";
+	STATUS_WORDS = {
+		backlog: "backlog",
+		todo: "todo",
+		"to-do": "todo",
+		"to do": "todo",
+		doing: "doing",
+		"in-progress": "doing",
+		"in progress": "doing",
+		started: "doing",
+		review: "review",
+		"in-review": "review",
+		"in review": "review",
+		done: "done",
+		finished: "done"
+	};
+	PRIORITIES = [
+		"low",
+		"medium",
+		"high",
+		"urgent"
+	];
+	REPEATS = [
+		"weekly",
+		"biweekly",
+		"monthly"
+	];
+	KEY_NAME = /^([A-Z][A-Z0-9]{0,9}-\d{1,7})\.md$/;
+	same = (a, b) => Array.isArray(a) && Array.isArray(b) ? a.join(",") === b.join(",") : a === b;
+	shown = (v) => Array.isArray(v) ? v.join(", ") || "nothing" : v === null || v === "" ? "nothing" : String(v);
 }));
 
 //#endregion
@@ -17715,6 +18174,75 @@ var init_repo_sync = __esmMin((() => {
 	};
 }));
 
+//#endregion
+//#region src/repo/folder.ts
+/**
+* The `.harbor/` folder on disk, and finding it: like git, `harbor sync`
+* works from anywhere inside the repository.
+*/
+function diskFolder(root) {
+	return {
+		async read(path) {
+			try {
+				return await readFile(join(root, path), "utf8");
+			} catch (error) {
+				if (error.code === "ENOENT") return null;
+				throw error;
+			}
+		},
+		async write(path, text) {
+			const file = join(root, path);
+			await mkdir(dirname(file), { recursive: true });
+			const temp = `${file}.${process.pid}.tmp`;
+			await writeFile(temp, text);
+			await rename(temp, file);
+		},
+		async remove(path) {
+			await rm(join(root, path), { force: true });
+		},
+		async list(dir) {
+			try {
+				return (await readdir(join(root, dir), { withFileTypes: true })).filter((d) => d.isFile()).map((d) => d.name);
+			} catch (error) {
+				if (error.code === "ENOENT") return [];
+				throw error;
+			}
+		}
+	};
+}
+/** The nearest `.harbor/` with a plan in it, from `start` up; null when there's none. */
+async function findPlan(start) {
+	let dir = resolve(start);
+	for (;;) {
+		const here = join(dir, PLAN_DIR);
+		try {
+			await readFile(join(here, CONFIG_FILE));
+			return here;
+		} catch {}
+		const up = dirname(dir);
+		if (up === dir) return null;
+		dir = up;
+	}
+}
+/** Where a new plan goes: the repository's top (the folder holding .git), else here. */
+async function planHome(start) {
+	let dir = resolve(start);
+	for (;;) {
+		try {
+			await access(join(dir, ".git"));
+			return dir;
+		} catch {}
+		const up = dirname(dir);
+		if (up === dir) return resolve(start);
+		dir = up;
+	}
+}
+var PLAN_DIR;
+var init_folder = __esmMin((() => {
+	init_plan_files();
+	PLAN_DIR = ".harbor";
+}));
+
 //#endregion
 //#region src/repo/commands.ts
 /**
@@ -23442,7 +23970,9 @@ init_format();
 init_date_text();
 init_handover();
 init_work();
+init_fog();
 init_board();
+init_soundings();
 /**
 * Where the website opens one task or project, switching to its harbor
 * first (src/routes/open.tsx). Nothing without an origin.
@@ -23494,8 +24024,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) {
-	const tide = tideForecast(project, tasks, now);
+function finishForecast(project, tasks, now, spend, reflections) {
+	const tide = tideForecast(project, tasks, now, { reflections });
 	if (tide.kind !== "forecast") return { none: tideQuiet(tide) };
 	const lastDue = dueAfterFinish(tide);
 	const dueLater = lastDue ? { lastDue: {
@@ -23521,6 +24051,7 @@ function finishForecast(project, tasks, now, spend) {
 		finishedPerWeek: tide.perWeek,
 		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.weeks < 2 ? { shortHistory: true } : {},
 		...dueLater,
 		...slip
@@ -23580,6 +24111,39 @@ function me(ctx) {
 }
 const nameOf = (people, id) => id && people.get(id)?.name || null;
 const isOpen = (t) => t.status !== "done";
+/**
+* A task's sounding as the caller may see it (src/lib/soundings.ts): who was
+* asked and who hasn't answered, their own answer, and everyone's with the
+* spread only once the answers show. Null when nobody asked.
+*/
+function soundingOut(data, t, meId, now) {
+	const read = readSounding(t, data.reflections, now);
+	if (!read) return null;
+	const people = byId(data.people);
+	const seen = meId ? visibleAnswers$1(read, meId) : read.shown ? read.answers : [];
+	return {
+		askedBy: nameOf(people, read.sounding.askedById),
+		asked: dayOf(read.sounding.askedAt),
+		crew: read.crewIds.map((id) => nameOf(people, id) ?? "Someone"),
+		answered: read.answers.length,
+		waitingOn: read.waitingOn.map((id) => nameOf(people, id) ?? "Someone"),
+		...meId && read.crewIds.includes(meId) ? { youWereAsked: true } : {},
+		shown: read.shown,
+		answers: seen.map((a) => ({
+			who: nameOf(people, a.authorId) ?? "Someone",
+			days: a.days,
+			...a.body ? { why: a.body } : {}
+		})),
+		...read.shown ? {
+			low: read.low,
+			high: read.high,
+			middle: read.middle
+		} : {},
+		...read.wide ? { talkFirst: true } : {},
+		estimateDays: read.estimate,
+		...read.sounding.settledDays != null ? { settled: true } : {}
+	};
+}
 const dayOf = (iso) => iso ? iso.slice(0, 10) : null;
 function overdue(t, today) {
 	const due = dayOf(t.dueDate);
@@ -23837,7 +24401,7 @@ const HARBOR_TOOLS = [
 							done: c.done,
 							late: c.late
 						},
-						finish: finishForecast(p, tasksOf(data.tasks, p.id), ctx.now),
+						finish: finishForecast(p, tasksOf(data.tasks, p.id), ctx.now, void 0, data.reflections),
 						...limitsOf(data, p.id),
 						...hillOf(p, today),
 						...publicRoadmap(ctx, p.id)
@@ -23908,7 +24472,7 @@ const HARBOR_TOOLS = [
 				waitsOn,
 				milestones,
 				openRaid: raid,
-				finish: finishForecast(p, tasks, ctx.now, spendEntriesOf(data, p.id)),
+				finish: finishForecast(p, tasks, ctx.now, spendEntriesOf(data, p.id), data.reflections),
 				...notesOf(ctx, p),
 				...hillOf(p, today),
 				...webLink(ctx, { project: p.id })
@@ -24016,6 +24580,7 @@ const HARBOR_TOOLS = [
 				})),
 				waitingOn: blockersOf(t, data.tasks).map(brief),
 				waitedOnBy: waiters.map(brief),
+				...t.sounding ? { sounding: soundingOut(data, t, me(ctx)?.id ?? null, ctx.now) } : {},
 				comments,
 				...webLink(ctx, { task: t.id })
 			};
@@ -24064,7 +24629,13 @@ const HARBOR_TOOLS = [
 				late: open.filter((t) => overdue(t, today)).length,
 				tasks: open.slice(0, input.limit).map((t) => taskLine(t, people, projects, data.tasks)),
 				waitingOnYou: waitingOnYou.slice(0, 20),
-				raid
+				raid,
+				soundingsToAnswer: soundingsWaitingOn(data, mine.id, ctx.now).map((t) => ({
+					id: t.id,
+					...taskKey(t, projects.get(t.projectId)) ? { key: taskKey(t, projects.get(t.projectId)) } : {},
+					title: t.title,
+					askedBy: nameOf(people, t.sounding.askedById)
+				}))
 			};
 		}
 	}),
@@ -24340,6 +24911,35 @@ const HARBOR_TOOLS = [
 			};
 		}
 	}),
+	tool({
+		name: "list_soundings",
+		title: "Soundings",
+		description: "Open tasks someone took a sounding on (asked a few people how many working days each will take), in one project or the whole harbor: who hasn't answered, and once the answers show, the spread, whether it's wide enough to talk through first (talkFirst), and the estimate. Answers show only once everyone has answered or someone shows them; until then you see only the person's own." + DATA_NOTE,
+		input: object({
+			harbor: harborArg,
+			project: string().min(1).max(200).optional().describe("Project id or name; all projects when left out.")
+		}),
+		run: (ctx, input) => {
+			const { data } = ctx;
+			const project = input.project ? findOne(data.projects, input.project, "project") : null;
+			const projects = byId(data.projects);
+			const meId = me(ctx)?.id ?? null;
+			const tasks = data.tasks.filter((t) => isOpen(t) && t.sounding && (!project || t.projectId === project.id));
+			return {
+				...project ? { project: project.name } : {},
+				soundings: tasks.map((t) => {
+					const key = taskKey(t, projects.get(t.projectId));
+					return {
+						id: t.id,
+						...key ? { key } : {},
+						title: t.title,
+						project: projects.get(t.projectId)?.name ?? null,
+						...soundingOut(data, t, meId, ctx.now)
+					};
+				})
+			};
+		}
+	}),
 	tool({
 		name: "shipping_forecast",
 		title: "The harbor forecast",
@@ -24431,6 +25031,38 @@ const HARBOR_TOOLS = [
 			};
 		}
 	}),
+	tool({
+		name: "fog",
+		title: "Tasks in fog",
+		description: "Open tasks nobody has opened, moved, edited or commented on for three weeks (thick fog after five), longest untouched first, with how long and when they're due. Walk the person through them one at a time: still needed (keep_task clears it), a new date (update_task), or drop it (only on the website or in the terminal; nothing here deletes)." + DATA_NOTE,
+		input: object({
+			harbor: harborArg,
+			project: string().max(200).optional().describe("Project id, key or name, for one only."),
+			limit: limitArg(100, 25),
+			offset: offsetArg
+		}),
+		run: (ctx, input) => {
+			const { data } = ctx;
+			const project = input.project ? findOne(data.projects, input.project, "project") : null;
+			const today = todayISO(ctx.now);
+			const fog = foggyTasks(data, today, project ? /* @__PURE__ */ new Set([project.id]) : void 0);
+			const people = byId(data.people);
+			const projects = byId(data.projects);
+			return {
+				...project ? { project: project.name } : {},
+				inFog: fog.length,
+				fogAfterDays: 21,
+				tasks: fog.slice(input.offset, input.offset + input.limit).map((f) => ({
+					...taskLine(f.task, people, projects, data.tasks),
+					untouchedDays: f.days,
+					untouched: untouchedText(f.days),
+					thick: f.level === "thick",
+					lastTouched: dayOf(lastTouch(f.task, data))
+				})),
+				more: fog.length > input.offset + input.limit
+			};
+		}
+	}),
 	tool({
 		name: "handover_plan",
 		title: "What handing someone's work over would move",
@@ -24490,61 +25122,6 @@ const LIST_HARBORS = {
 	input: object({})
 };
 
-//#endregion
-//#region src/lib/command-line.ts
-init_date_fns();
-init_format();
-const PAGES = {
-	today: "/today",
-	inbox: "/inbox",
-	brief: "/brief",
-	review: "/review",
-	portfolios: "/portfolios",
-	programs: "/programs",
-	projects: "/projects",
-	risks: "/risks",
-	calendar: "/calendar",
-	people: "/people"
-};
-const HELP = [
-	{ text: "add \"TITLE\" [#project] [@person] [--due fri|+3|2026-11-02]" },
-	{ text: "mine                    what's on you, late first" },
-	{ text: "tasks [words] [--late] [#project] [@person]" },
-	{ text: "show RR-12             open a task" },
-	{ text: "start | review | done RR-12" },
-	{ text: "comment RR-12 \"TEXT\"" },
-	{ text: "checkin \"WHAT YOU'RE ON\" [--on-blocker]" },
-	{ text: `go ${Object.keys(PAGES).join("|")}` },
-	{
-		text: "undo · clear · help",
-		tone: "muted"
-	}
-];
-var CommandError = class extends Error {};
-const WEEKDAYS = [
-	"sun",
-	"mon",
-	"tue",
-	"wed",
-	"thu",
-	"fri",
-	"sat"
-];
-/** today, tomorrow, +N, a weekday (the next one, never today) or YYYY-MM-DD. */
-function dueFrom(value, now) {
-	const v = value.trim().toLowerCase();
-	if (v === "today") return todayISO(now);
-	if (v === "tomorrow") return todayISO(addDays(now, 1));
-	if (/^\+\d{1,3}$/.test(v)) return todayISO(addDays(now, Number(v.slice(1))));
-	const day = WEEKDAYS.findIndex((d) => v.startsWith(d) && d.length >= 3 && v.length >= 3);
-	if (day >= 0) {
-		const ahead = (day - now.getDay() + 7) % 7 || 7;
-		return todayISO(addDays(now, ahead));
-	}
-	if (/^\d{4}-\d{2}-\d{2}$/.test(v) && !Number.isNaN(parseDate$1(v).getTime())) return v;
-	throw new CommandError(`Can't read the date "${value}". Try today, fri, +3 or 2026-11-02.`);
-}
-
 //#endregion
 //#region src/lib/dry-dock.ts
 init_date_fns();
@@ -25088,6 +25665,8 @@ init_transport();
 init_errors();
 init_plain();
 init_search();
+init_view_only();
+init_repo_sync();
 const today = () => format(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
 /** How long `harbor` shows its splash at the least, however fast the harbor loads. */
 const SPLASH_MS = 1200;
@@ -25221,8 +25800,58 @@ async function runApp(opts) {
 	}, { alternateScreen: true });
 	await instance.waitUntilExit();
 }
+/**
+* The harbor a one-off run works in, without asking: --harbor, else the one
+* `harbor use` saved, else the only one.
+*/
+function harborFor(harbors, named, saved) {
+	if (harbors.length === 0) throw new HarborError("You're not in a harbor yet. Run harbor to make one first.");
+	if (named) return harborNamed(harbors, named);
+	const kept = saved ? harbors.find((h) => h.id === saved) : void 0;
+	if (kept) return kept;
+	if (harbors.length === 1) return harbors[0];
+	throw new HarborError(`You're in ${harbors.length} harbors (${harbors.map((h) => h.name).join(", ")}). Add --harbor NAME, or run harbor use NAME first.`);
+}
+/** `harbor fog` in a terminal: the sweep, one task at a time, then one save. */
+async function fogHere(opts) {
+	const transport = plainTransport(httpTransport(opts.source, opts.fetcher));
+	const answer = await transport.harbors();
+	const harbor = harborFor(answer.harbors, opts.harbor, opts.saved);
+	const say = (line) => process.stdout.write(`${plain(line)}\n`);
+	const store = createAppStore();
+	const sync = createSync({
+		store,
+		transport,
+		account: {
+			id: answer.account.id,
+			name: answer.account.name || answer.account.email
+		},
+		live: false,
+		saveDelayMs: 0,
+		onNotice: say
+	});
+	await sync.open(harbor.id);
+	const terminal = terminalAsk("Stopped. What you'd answered is saved.");
+	try {
+		if (readOnlyHarbor(store.getState())) throw new HarborError(store.getState().keepPaused ? PAUSED_NOTICE : `You can only view ${harbor.name}, so there's no fog to clear from here.`);
+		const project = opts.project ? projectNamed(store.getState().projects, opts.project) : null;
+		await sweepFog({
+			store,
+			ask: terminal.ask,
+			say,
+			today: today(),
+			now: /* @__PURE__ */ new Date(),
+			projectId: project?.id ?? null
+		});
+	} finally {
+		terminal.close();
+		await sync.flush();
+		sync.close();
+	}
+	if (sync.state !== "saved") throw new HarborError("Harbor didn't take those answers. Run harbor fog again.");
+}
 /** Questions asked on the plain terminal, before the app takes it over. Ctrl+C stops. */
-function terminalAsk() {
+function terminalAsk(stoppedText = "Stopped. Nothing was made.") {
 	const rl = createInterface({
 		input: process.stdin,
 		output: process.stdout
@@ -25230,7 +25859,7 @@ function terminalAsk() {
 	let stop = () => {};
 	const stopped = new Promise((_, reject) => stop = reject);
 	stopped.catch(() => {});
-	const nothing = () => stop(new HarborError("Stopped. Nothing was made."));
+	const nothing = () => stop(new HarborError(stoppedText));
 	rl.on("SIGINT", nothing);
 	rl.on("close", nothing);
 	return {
@@ -25262,4 +25891,4 @@ function planTransport(source, fetcher) {
 }
 
 //#endregion
-export { SPLASH_MS, TransportError, firstHarbor, harborNamed, httpTransport, initHere, initLocalHere, localPlanAt, planTransport, runApp, runLocalApp, startApp, syncHere, tryHere };
+export { SPLASH_MS, TransportError, firstHarbor, fogHere, harborNamed, httpTransport, initHere, initLocalHere, localPlanAt, planTransport, runApp, runLocalApp, startApp, syncHere, tryHere };