@harborppm/cli 0.48.0 → 0.49.0

package/README.md

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

package/dist/app.mjs

@@ -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;
@@ -14858,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();
@@ -14867,6 +15112,8 @@ var init_tasks = __esmMin((() => {
 	init_automations();
 	init_focus();
 	init_format();
+	init_soundings();
+	init_clock();
 	init_utils();
 	init_blockers();
 	init_work();
@@ -23725,6 +23972,7 @@ 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.
@@ -23776,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: {
@@ -23803,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
@@ -23862,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);
@@ -24119,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)
@@ -24190,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 })
@@ -24298,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 })
 			};
@@ -24346,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)
+				}))
 			};
 		}
 	}),
@@ -24622,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",

package/lib/cli.mjs

@@ -33,6 +33,9 @@ import {
   myWork,
   premortemText,
   notesText,
+  daysText,
+  soundingText,
+  soundingsText,
   voyageText,
   handoverText,
   fogText,
@@ -175,6 +178,12 @@ export const HELP = `harbor: Harbor from the terminal
   harbor note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]
                                               a note for later: sealed until
                                               its day, milestone, or Off track
+  harbor sound TASK [DAYS] [--why TEXT] [--ask NAMES|crew] [--settle DAYS]
+                                              a sounding: ask a few people how
+                                              many days a task will take, give
+                                              your answer, or read the spread
+  harbor soundings [PROJECT]                  open tasks with a sounding, and
+                                              the ones waiting on your answer
   harbor handover PERSON [--to NAME] [--until DATE] [--note TEXT]
                          [--keep ID,ID] [--confirm]
                                               hand someone's work to the crew
@@ -369,6 +378,9 @@ const FLAG = {
   to: "--to",
   keep: "--keep",
   person: "the person",
+  days: "the days",
+  why: "--why",
+  people: "--ask",
 };
 
 /** Harbor's refusals are worded for agents; say them as the commands and flags that answer them. */
@@ -606,6 +618,25 @@ const DETAIL = {
     "  --no-people. A task already in its project is left alone: by its key",
     "  (a Key column, as harbor export writes) or by title.",
   ],
+  sound: [
+    "  harbor sound TASK                      reads its sounding: who hasn't answered,",
+    "                                         and the spread once everyone has",
+    "  harbor sound TASK --ask crew           writes: asks you, its owner and whoever",
+    "                                         has open work on its project",
+    '  harbor sound TASK --ask "Sam,Priya"    writes: asks those people',
+    '  harbor sound TASK 4 [--why "TEXT"]     writes: your answer, in working days',
+    "  harbor sound TASK --settle 6           writes: the days you agreed on after",
+    "                                         talking a wide spread through",
+    "",
+    "  Each person answers alone, and nobody sees the others' numbers until",
+    "  everyone has. Close guesses give the task an estimate; far-apart ones",
+    "  say talk first. The forecast draws on every answer.",
+  ],
+  soundings: [
+    "  harbor soundings [PROJECT]             reads: open tasks with a sounding",
+    "                                         (all projects when left out), and the",
+    "                                         ones waiting on your answer",
+  ],
   note: [
     "  harbor note PROJECT                    reads its notes for later: who left",
     "                                         each, what opens it, and the opened ones",
@@ -2051,6 +2082,65 @@ export async function run(argv, io = {}) {
         (r) => `Sealed your note on ${r.sealed.project}. It ${r.sealed.opens}.`,
       );
     }
+    case "sound": {
+      const { positionals, values, harbor } = parse(spec([], ["why", "ask", "settle"]));
+      const [task, days, ...extra] = positionals;
+      if (!task) throw new HarborError("Give a task's key, like harbor sound RR-4.");
+      if (extra.length) throw new HarborError(`Unexpected "${extra.join(" ")}".`);
+      const number = (text) => {
+        const n = Number(String(text).replace(/d(ays?)?$/i, ""));
+        if (!Number.isFinite(n) || n <= 0)
+          throw new HarborError(`Give days as a number, like 3 or 2.5 (not "${text}").`);
+        return n;
+      };
+      const given = [days !== undefined, values.ask !== undefined, values.settle !== undefined];
+      if (given.filter(Boolean).length > 1)
+        throw new HarborError("Answer, ask or settle: one at a time.");
+      if (values.why !== undefined && days === undefined)
+        throw new HarborError('--why goes with your answer: harbor sound TASK 4 --why "TEXT".');
+      if (values.ask !== undefined) {
+        const crew = /^crew$/i.test(values.ask.trim())
+          ? undefined
+          : values.ask
+              .split(",")
+              .map((x) => x.trim())
+              .filter(Boolean);
+        return call(
+          "take_sounding",
+          { harbor, task, ...(crew ? { people: crew } : {}) },
+          (r) =>
+            `Asked ${r.asked.people.join(", ")} how many days ${r.asked.key ?? r.asked.title} will take. The answers show together once everyone's in.`,
+        );
+      }
+      if (values.settle !== undefined) {
+        return call(
+          "settle_sounding",
+          { harbor, task, days: number(values.settle) },
+          (r) => `Settled ${r.settled.key ?? r.settled.title} at ${daysText(r.settled.days)}.`,
+        );
+      }
+      if (days !== undefined) {
+        return call(
+          "answer_sounding",
+          { harbor, task, days: number(days), ...(values.why ? { why: values.why } : {}) },
+          (r) => soundingText(r.answered, r.sounding, { answered: true }),
+        );
+      }
+      return call(
+        "get_task",
+        { harbor, task },
+        (r) => soundingText(r, r.sounding ?? null),
+        (r) => ({ id: r.id, key: r.key ?? null, title: r.title, sounding: r.sounding ?? null }),
+      );
+    }
+    case "soundings": {
+      const { positionals, harbor } = parse(spec());
+      const [project, ...extra] = positionals;
+      if (extra.length) throw new HarborError(`Unexpected "${extra.join(" ")}".`);
+      return call("list_soundings", { harbor, ...(project ? { project } : {}) }, (r) =>
+        soundingsText(r),
+      );
+    }
     case "voyage": {
       const { positionals, harbor } = parse(spec());
       const [project, ...words] = positionals;

package/lib/format.mjs

@@ -600,6 +600,78 @@ export function notesText(project, notes) {
   return lines.join("\n");
 }
 
+/** "half a day", "1 day", "2.5 days". */
+export function daysText(days) {
+  if (days === 0.5) return "half a day";
+  return `${days} day${days === 1 ? "" : "s"}`;
+}
+
+/** The spread as a line of dots, 0 to the highest guess, like the website's. */
+function spreadLine(answers, width = 30) {
+  const days = answers.map((a) => a.days);
+  const top = Math.max(5, ...days);
+  const cells = Array(width + 1).fill("·");
+  for (const d of days) cells[Math.round((d / top) * width)] = "●";
+  return `0 ${cells.join("")} ${daysText(top)}`;
+}
+
+/** One task's sounding: who's left to answer, or the spread and what it means. */
+export function soundingText(task, s, { answered = false } = {}) {
+  const name = task.key ? `${task.key} ${task.title}` : task.title;
+  if (!s)
+    return `No sounding on ${name}. Ask the crew: harbor sound ${task.key ?? task.id} --ask crew`;
+  const lines = [`Sounding · ${name} · ${s.answered} of ${s.crew.length} answered`];
+  if (answered) lines[0] = `Your answer is in. ${lines[0]}`;
+  if (!s.shown) {
+    if (s.waitingOn.length) lines.push(`  Waiting on ${s.waitingOn.join(", ")}.`);
+    lines.push("  The answers show together once everyone's in.");
+    for (const a of s.answers)
+      lines.push(`  You said ${daysText(a.days)}${a.why ? ` · "${a.why}"` : ""}`);
+    if (s.youWereAsked && !s.answers.length)
+      lines.push(`  Give yours: harbor sound ${task.key ?? task.id} DAYS`);
+    return lines.join("\n");
+  }
+  lines.push(`  ${spreadLine(s.answers)}`);
+  for (const a of s.answers)
+    lines.push(`  ${a.who}: ${daysText(a.days)}${a.why ? ` · "${a.why}"` : ""}`);
+  if (s.settled) lines.push(`  Settled on ${daysText(s.estimateDays)}.`);
+  else if (s.talkFirst)
+    lines.push(
+      `  Talk about this first: ${daysText(s.low)} to ${daysText(s.high)} means someone sees work the others don't.`,
+      `  Once you've talked: harbor sound ${task.key ?? task.id} --settle DAYS`,
+    );
+  else lines.push(`  Close enough: about ${daysText(s.estimateDays)}.`);
+  return lines.join("\n");
+}
+
+/** list_soundings: the ones waiting on you first, then the rest, wide ones flagged. */
+export function soundingsText(r) {
+  const all = r.soundings ?? [];
+  const where = r.project ? ` on ${r.project}` : "";
+  if (!all.length)
+    return `No soundings${where}. Ask how long a task will take: harbor sound TASK --ask crew`;
+  const name = (t) => (t.key ? `${t.key} ${t.title}` : t.title);
+  const yours = all.filter((t) => t.youWereAsked && !t.answers.length && !t.shown);
+  const lines = [];
+  if (yours.length) {
+    lines.push("Waiting on your answer");
+    for (const t of yours) lines.push(`  ${name(t)} · asked by ${t.askedBy ?? "someone"}`);
+    lines.push("");
+  }
+  lines.push(`Soundings${where}`);
+  for (const t of all) {
+    const state = t.settled
+      ? `settled · ${daysText(t.estimateDays)}`
+      : t.talkFirst
+        ? `talk first · ${daysText(t.low)} to ${daysText(t.high)}`
+        : t.shown
+          ? `about ${daysText(t.estimateDays)}`
+          : `${t.answered} of ${t.crew.length} answered`;
+    lines.push(`  ${name(t)} · ${state}`);
+  }
+  return lines.join("\n");
+}
+
 /** handover_plan as a list grouped like the website's dialog, each line with who takes it. */
 export function handoverText(r, { confirmHint = true } = {}) {
   const items = r.items ?? [];

package/package.json

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