@harborppm/cli 0.56.0 → 0.58.0

package/README.md

@@ -81,6 +81,7 @@ due: 2026-11-07
 priority: high
 waits: [CS-2]
 ---
+
 Old endpoints go away on Nov 20.
 ```
 
@@ -199,8 +200,10 @@ harbor init --local [NAME]                  a plan in this folder alone, no acco
 harbor sync [--quiet] [--dry-run]           the files and the website, in step both ways
 harbor handover PERSON [--to NAME] [--until DATE] [--note TEXT] [--keep ID,ID] [--confirm]
 harbor handback PERSON
-harbor fog [--project P] [--list]           tasks nobody has touched for three weeks, one at a time
+harbor fog [--project P]                    tasks nobody has touched for three weeks, longest first
+harbor fog --sweep [--project P]            the same, one at a time: still needed, a new date, or drop it
 harbor fog keep TASK                        it's still needed: out of the fog
+harbor watch [--project P] [--bell]         a live ticker of the harbor's changes
 harbor lifeboats [--program P]              work only one person knows, each with a second pair of hands
 harbor lifeboats N [--person NAME]          adds that second pair of hands
 harbor follow TASK|"RISK" --person NAME     someone follows it too
@@ -210,7 +213,9 @@ harbor agent report TASK "WHAT YOU DID" [--start] [--agent NAME]
 
 `harbor handover Priya` lists everything Priya carries (open tasks, sign-offs waiting on her, risks and issues she owns, projects and programs she leads) and who should take each, from who has room this week. Nothing moves until you add `--confirm`. `--until DATE` is for time away: Priya shows as away on People, and `harbor handback Priya` gives back whatever is still with whoever took it. `--note` goes with each task and risk as a comment.
 
-`harbor fog` walks through the open tasks nobody has opened, moved, edited or commented on for three weeks, one at a time: `k` still needed (clears the fog), `d` a new date, `x` drop it, `s` skip, `q` stop. Piped or with `--list` it just lists them. On the board, in the app and on the website, those cards show dimmed.
+`harbor fog` lists the open tasks nobody has opened, moved, edited or commented on for three weeks, longest first. `harbor fog --sweep` walks through them one at a time in a terminal: `k` still needed (clears the fog), `d` a new date, `x` drop it, `s` skip, `q` stop. On the board, in the app and on the website, those cards show dimmed.
+
+`harbor watch` turns a narrow split or a tmux pane into a live ticker of your harbor: cards moving, comments, health changes, a line each as they happen, over the same live updates the website uses. Lines about your own work (your tasks, mentions of you, what you lead) are bright and the rest dim; `--bell` rings the terminal's bell when something of yours changes, and `--project` keeps to one project. `q` stops.
 
 `harbor lifeboats` lists the work only one person has touched (a project, their corner of one, a task others wait on, their serious risks), numbered, each with someone who has room this week and already works nearby. `harbor lifeboats 2` puts that person on line 2 as a second pair of hands (`--person NAME` for someone else); `harbor follow RR-4 --person Sam` does it for one task. Following doesn't take the work over. `harbor raid "DECISION" --still-stands "WHY"` says a decision that came back for a look still stands.
 

package/dist/app.mjs

@@ -34,12 +34,17 @@ var __exportAll = (all, no_symbols) => {
 
 //#endregion
 //#region src/lib/clock.ts
+/** A date's local wall-clock time, with no zone: "2026-10-05T23:10:00". */
+function wallClock(d = /* @__PURE__ */ new Date()) {
+	return `${d.getFullYear()}-${pad$1(d.getMonth() + 1)}-${pad$1(d.getDate())}T${pad$1(d.getHours())}:${pad$1(d.getMinutes())}:${pad$1(d.getSeconds())}`;
+}
 function clockNow() {
 	return frozen ? new Date(frozen) : /* @__PURE__ */ new Date();
 }
-var frozen;
+var frozen, pad$1;
 var init_clock = __esmMin((() => {
 	frozen = null;
+	pad$1 = (n) => String(n).padStart(2, "0");
 }));
 
 //#endregion
@@ -2274,9 +2279,158 @@ var init_premortem = __esmMin((() => {
 }));
 
 //#endregion
-//#region src/lib/voyage-log.ts
+//#region src/lib/charter-lines.ts
+/** Nothing written on any of the five lines. */
+function charterEmpty(charter) {
+	return !charter || CHARTER_FIELDS.every((f) => !clean(charter[f]));
+}
+/**
+* The charter after a change to some of its lines: trimmed, and null once
+* every line is empty so a cleared charter reads as never written.
+*/
+function withCharter(current, patch, by, at) {
+	const next = {
+		...current ?? {},
+		updatedAt: at,
+		updatedById: by
+	};
+	for (const field of CHARTER_FIELDS) {
+		if (!(field in patch)) continue;
+		const text = (patch[field] ?? "").trim();
+		if (text) next[field] = text;
+		else delete next[field];
+	}
+	return charterEmpty(next) ? null : next;
+}
+var CHARTER_FIELDS, clean;
+var init_charter_lines = __esmMin((() => {
+	CHARTER_FIELDS = [
+		"why",
+		"inScope",
+		"outScope",
+		"doneWhen",
+		"callsBy"
+	];
+	clean = (s) => (s ?? "").replace(/\s+/g, " ").trim();
+}));
+
+//#endregion
+//#region src/lib/charter.ts
 init_indexes();
 init_date_fns();
+init_date_text();
+init_premortem();
+init_charter_lines();
+const CHARTER_LABEL = {
+	why: "Why",
+	inScope: "In",
+	outScope: "Out",
+	doneWhen: "Done when",
+	callsBy: "Calls made by"
+};
+/** Each line's name for agents and the CLI's --json: plain words, no "Scope". */
+const CHARTER_KEY = {
+	why: "why",
+	inScope: "in",
+	outScope: "out",
+	doneWhen: "doneWhen",
+	callsBy: "callsBy"
+};
+/** The lines written so far, in order. */
+function charterLines(charter) {
+	if (!charter) return [];
+	return CHARTER_FIELDS.map((field) => ({
+		field,
+		label: CHARTER_LABEL[field],
+		text: clean(charter[field])
+	})).filter((l) => l.text);
+}
+function charterFilled(charter) {
+	return charterLines(charter).length;
+}
+/** A week after the start, an empty charter is worth a nudge. */
+const CHARTER_GRACE_DAYS = 7;
+/**
+* A project whose charter is still blank a week after it started, while
+* it's still running. Done and paused ones are left alone.
+*/
+function charterOverdue(project, today) {
+	if (project.health === "done" || project.health === "paused") return null;
+	if (!charterEmpty(project.charter)) return null;
+	const days = differenceInCalendarDays(parseIso(today), parseIso(project.startDate.slice(0, 10)));
+	return days >= 7 ? days : null;
+}
+/** The items of an In or Out line: split on commas, semicolons, "and" lists and new lines. */
+function charterItems(text) {
+	return (text ?? "").split(/[\n,;•]+/).map((s) => s.replace(/^\s*(?:and|or|-|\*)\s+/i, "").trim()).filter((s) => contentWords(s).size > 0);
+}
+/** True when a task's title names an item: every meaningful word of a short item, or two of a longer one. */
+function names(item, title) {
+	let shared = 0;
+	for (const w of item) if (title.has(w)) shared += 1;
+	return item.size <= 2 ? shared === item.size : shared >= 2;
+}
+/**
+* Tasks whose titles name something the charter put out of scope, newest
+* first: the "I thought that was in" list. Tasks made before the charter
+* was last written are left out when `since` is given, so writing an Out
+* line about work already on the board doesn't flag it.
+*/
+function outOfScope(charter, tasks, opts = {}) {
+	const items = charterItems(charter?.outScope).map((item) => ({
+		item,
+		words: contentWords(item)
+	}));
+	if (items.length === 0) return [];
+	const out = [];
+	for (const task of tasks) {
+		if (opts.since && task.createdAt < opts.since) continue;
+		const title = contentWords(task.title);
+		const hit = items.find((i) => names(i.words, title));
+		if (hit) out.push({
+			task,
+			item: hit.item
+		});
+	}
+	return out.sort((a, b) => b.task.createdAt.localeCompare(a.task.createdAt));
+}
+/** The voyage log's look at the charter: did the In list get done, did the Out list stay out. */
+function charterCheck(charter, tasks) {
+	if (charterEmpty(charter)) return null;
+	const finished = tasks.filter((t) => t.status === "done").map((t) => contentWords(t.title));
+	const delivered = charterItems(charter.inScope).map((item) => {
+		const words = contentWords(item);
+		return {
+			item,
+			done: finished.filter((title) => names(words, title)).length
+		};
+	});
+	return {
+		doneWhen: clean(charter.doneWhen) || null,
+		delivered,
+		crept: outOfScope(charter, tasks),
+		outItems: charterItems(charter.outScope).length
+	};
+}
+/** One sentence for the voyage log's story; null when there's no charter. */
+function charterSentence(check) {
+	if (!check) return null;
+	const bits = [];
+	if (check.delivered.length) {
+		const missing = check.delivered.filter((d) => d.done === 0).map((d) => d.item);
+		bits.push(missing.length === 0 ? "every item the charter put in has finished work against it" : `${check.delivered.length - missing.length} of ${check.delivered.length} items the charter put in have finished work against them (not: ${missing.join(", ")})`);
+	}
+	if (check.crept.length) {
+		const items = [...new Set(check.crept.map((c) => c.item))];
+		bits.push(`${check.crept.length} task${check.crept.length === 1 ? "" : "s"} touched what it put out (${items.join(", ")})`);
+	} else if (check.outItems > 0) bits.push("nothing it put out crept in");
+	if (!bits.length) return null;
+	return `Against the charter: ${bits.join("; ")}.`;
+}
+
+//#endregion
+//#region src/lib/voyage-log.ts
+init_date_fns();
 init_blockers();
 init_date_text();
 init_premortem();
@@ -2342,6 +2496,7 @@ function voyageLog(data, projectId) {
 		slips,
 		risks,
 		issues: issues.length,
+		charter: charterCheck(project.charter, tasks),
 		decisions,
 		carriers,
 		budget: project.budget,
@@ -2390,6 +2545,8 @@ function voyageStory(log) {
 		out.push(s.waitedOn ? `${late}; it waited on “${s.waitedOn.title}”, done ${md$2(s.waitedOn.completedAt)}.` : `${late}.`);
 	}
 	for (const r of log.risks.filter((x) => x.happened)) out.push(`The risk “${r.risk.title}” came true${r.guessed ? " (an issue names it)" : ""}.`);
+	const against = charterSentence(log.charter);
+	if (against) out.push(against);
 	if (log.decisions.length) {
 		const changed = log.decisions.filter((d) => d.status === "superseded").length;
 		out.push(`${plural$4(log.decisions.length, "decision was", "decisions were")} written down${changed ? `; ${changed === 1 ? "one was" : `${changed} were`} changed later` : ""}.`);
@@ -5026,6 +5183,29 @@ function premortemNote(data, project, now, today) {
 	const pending = answersOf(data.reflections, project.id).filter(isPending).length;
 	return pending ? `pre-mortem: ${pending} to sort · P` : "pre-mortem · P";
 }
+/**
+* The charter in a few words for the project's header: how many of its five
+* lines are written and any open task that names what it leaves out, or a
+* nudge (warned once it's a week overdue). Null on a finished project with none.
+*/
+function charterNote(project, tasks, today) {
+	const filled = charterFilled(project.charter);
+	if (filled === 0) {
+		if (project.health === "done") return null;
+		return {
+			text: "no charter yet · e writes it",
+			warn: charterOverdue(project, today) !== null
+		};
+	}
+	const creep = outOfScope(project.charter, tasksOf(tasks, project.id).filter((t) => t.status !== "done")).length;
+	return creep ? {
+		text: `charter: ${creep} task${creep === 1 ? "" : "s"} look out of scope · e`,
+		warn: true
+	} : {
+		text: `charter ${filled} of 5 · e`,
+		warn: false
+	};
+}
 const ROLE_LABEL = {
 	owner: "Owner",
 	member: "Can edit",
@@ -6311,7 +6491,7 @@ function composeBriefBody(opts) {
 	}
 	return lines.join("\n").trim();
 }
-function firstName$1(person) {
+function firstName$2(person) {
 	return person?.name.split(/\s+/)[0] ?? "Someone";
 }
 function similar(a, b) {
@@ -6349,7 +6529,7 @@ function headlineOf(drums, flow) {
 	}
 	if (idle.length === 1) {
 		const d = idle[0];
-		return d.owner ? `${firstName$1(d.owner)} is in play elsewhere. ${d.constraint.title} is starving.` : `${d.constraint.title} is idle. Protect it or retire it.`;
+		return d.owner ? `${firstName$2(d.owner)} is in play elsewhere. ${d.constraint.title} is starving.` : `${d.constraint.title} is idle. Protect it or retire it.`;
 	}
 	if (idle.length > 1) return `${idle.length} constraints are idle. The work is not at the constraint.`;
 	if (system && flow.impliedDays != null && flow.impliedDays > 21) return `At this load, ${formatWait(flow.impliedDays)}. ${system.constraint.title}.`;
@@ -6413,7 +6593,7 @@ function briefOf(data, opts = {}) {
 	for (const d of drums.filter((x) => x.idle)) push({
 		id: `idle-${d.constraint.id}`,
 		title: `${d.constraint.title} is idle`,
-		detail: d.owner ? `${firstName$1(d.owner)} is in play elsewhere. ${d.program.name} is waiting.` : `${d.program.name} has a named constraint and nobody protecting it.`,
+		detail: d.owner ? `${firstName$2(d.owner)} is in play elsewhere. ${d.program.name} is waiting.` : `${d.program.name} has a named constraint and nobody protecting it.`,
 		href: `/programs/${d.program.id}`
 	});
 	for (const d of drums.filter((x) => x.constraint.kind === "collision" && !x.idle)) push({
@@ -7416,6 +7596,24 @@ function reviewPrograms(data, opts = {}) {
 	const { ownerId, portfolioId } = opts;
 	return data.programs.filter((p) => (!portfolioId || p.portfolioId === portfolioId) && (!ownerId || programTouches(p, data, ownerId))).sort((a, b) => rankHealth(a.health) - rankHealth(b.health) || a.endDate.localeCompare(b.endDate));
 }
+/**
+* The projects in these programs whose charter is still blank a week after
+* they started (src/lib/charter.ts), longest-running first: the review's
+* nudge to write the five lines.
+*/
+function blankCharters(data, programs, today) {
+	const ids = new Set(programs.filter((p) => p.health !== "done").map((p) => p.id));
+	const out = [];
+	for (const project of data.projects) {
+		if (!ids.has(project.programId)) continue;
+		const days = charterOverdue(project, today);
+		if (days !== null) out.push({
+			project,
+			days
+		});
+	}
+	return out.sort((a, b) => b.days - a.days || a.project.name.localeCompare(b.project.name));
+}
 
 //#endregion
 //#region src/tui/moves.ts
@@ -8386,7 +8584,7 @@ const PING_KIND_LABEL = {
 	idle: "Quiet blockers",
 	mention: "Mentions"
 };
-function firstName(name) {
+function firstName$1(name) {
 	return name.split(/\s+/)[0] ?? name;
 }
 /** FNV-1a over the text, as eight hex digits: a short, stable name for a set of ids. */
@@ -8425,7 +8623,7 @@ function inboxOf(data, personId, now = clockNow()) {
 		pings.push({
 			id: `assigned:${task.id}:${task.assignedAt}`,
 			kind: "assigned",
-			title: by ? `${firstName(by.name)} gave you a task` : "You have a new task",
+			title: by ? `${firstName$1(by.name)} gave you a task` : "You have a new task",
 			detail: `“${task.title}”${project ? ` · ${project.name}` : ""}`,
 			at: task.assignedAt,
 			taskId: task.id,
@@ -8439,7 +8637,7 @@ function inboxOf(data, personId, now = clockNow()) {
 		const project = projectOf(data, blocker);
 		const names = [...new Set(waiting.map((t) => {
 			const who = data.people.find((p) => p.id === t.assigneeId);
-			return who ? firstName(who.name) : "Someone";
+			return who ? firstName$1(who.name) : "Someone";
 		}))];
 		const blocked = waiting.length === 1 ? `“${waiting[0].title}”` : `${waiting.length} tasks`;
 		const upstream = openBlockerNames(blocker, data.tasks);
@@ -8474,7 +8672,7 @@ function inboxOf(data, personId, now = clockNow()) {
 			pings.push({
 				id: `changes:${m.id}:${shortHash(note)}`,
 				kind: "approval",
-				title: `${approver ? firstName(approver.name) : "The approver"} asked for changes to ${m.name}`,
+				title: `${approver ? firstName$1(approver.name) : "The approver"} asked for changes to ${m.name}`,
 				detail: note ? `${where}${excerpt(note)}` : program?.name ?? "",
 				at: m.dueDate,
 				programId: m.programId,
@@ -8520,7 +8718,7 @@ function inboxOf(data, personId, now = clockNow()) {
 		pings.push({
 			id: `sounding:${task.id}:${s.askedAt}`,
 			kind: "sounding",
-			title: `${by ? firstName(by.name) : "Someone"} asked how long a task will take`,
+			title: `${by ? firstName$1(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,
@@ -8537,7 +8735,7 @@ function inboxOf(data, personId, now = clockNow()) {
 		pings.push({
 			id: `mention:${comment.id}`,
 			kind: "mention",
-			title: author ? `${firstName(author.name)} mentioned you` : "You were mentioned",
+			title: author ? `${firstName$1(author.name)} mentioned you` : "You were mentioned",
 			detail: snippet ? `on “${task.title}”${project ? ` · ${project.name}` : ""} — ${snippet}` : `on “${task.title}”${project ? ` · ${project.name}` : ""}`,
 			at: comment.createdAt,
 			taskId: task.id,
@@ -10070,7 +10268,17 @@ function ProjectPanel({ id, width, height, go, active, onClose }) {
 				initial: project.description,
 				onSave: (v) => up({ description: v })
 			}
-		}
+		},
+		...CHARTER_FIELDS.map((f) => ({
+			label: `Charter: ${CHARTER_LABEL[f].toLowerCase()}`,
+			value: project.charter?.[f]?.replace(/\s+/g, " ") || "Not written",
+			color: project.charter?.[f] ? void 0 : theme.muted,
+			edit: {
+				kind: "text",
+				initial: project.charter?.[f] ?? "",
+				onSave: (v) => store.getState().setCharter(id, { [f]: v })
+			}
+		}))
 	];
 	return /* @__PURE__ */ jsx(DetailPanel, {
 		title: /* @__PURE__ */ jsx(Text, {
@@ -10708,6 +10916,8 @@ function ProjectsView({ active, width, height, go }) {
 		}
 	});
 }
+/** Projects a week in without a charter, in a few words; null for none. */
+const charterGap = (n) => n ? `${n} blank charter${n === 1 ? "" : "s"}` : null;
 /**
 * The review, as on the website: programs worst first, then by end date,
 * each with its lead, how much is late, where it sits on the priority matrix
@@ -10773,7 +10983,8 @@ function ProgramsView({ active, width, height, go }) {
 					late ? `${late} late` : null,
 					slip >= 100 ? `slipping costs ${dollars$1(slip)}` : null,
 					isRated(program) ? quadrantOf(program, maxBudget, rules) : null,
-					program.nextMove ? `next: ${program.nextMove}` : "no next move"
+					program.nextMove ? `next: ${program.nextMove}` : "no next move",
+					charterGap(blankCharters({ projects }, [program], day).length)
 				].filter(Boolean).join(" · ")
 			};
 		});
@@ -18100,6 +18311,7 @@ function me(ctx) {
 	return ctx.data.people.find((p) => p.accountId === ctx.accountId) ?? null;
 }
 const nameOf$2 = (people, id) => id && people.get(id)?.name || null;
+const LIFEBOATS_ALONE = "Nobody else on the crew yet; harbor invite EMAIL adds someone.";
 /** One line of "only one person knows these" (src/lib/lifeboats.ts), for an agent. */
 function lifeboatOut(data, line, people) {
 	return {
@@ -18297,6 +18509,24 @@ function decisionOut(data, r, people) {
 	};
 }
 const tool = (t) => t;
+/** A project's charter, as get_project gives it: the lines written, and open tasks that name what it leaves out. */
+function charterOf(p, tasks) {
+	const lines = charterLines(p.charter);
+	if (lines.length === 0) return { charter: null };
+	const creep = outOfScope(p.charter, tasks.filter((t) => t.status !== "done")).slice(0, 10);
+	return {
+		charter: {
+			...Object.fromEntries(lines.map((l) => [CHARTER_KEY[l.field], l.text])),
+			...p.charter?.updatedAt ? { updated: dayOf(p.charter.updatedAt) } : {}
+		},
+		...creep.length ? { outOfScope: creep.map((c) => ({
+			task: taskKey(c.task, p) ?? c.task.id,
+			title: c.task.title,
+			names: c.item,
+			added: dayOf(c.task.createdAt)
+		})) } : {}
+	};
+}
 /** A project's notes for later, as get_project gives them: sealed ones without their text unless they're the caller's. */
 function notesOf(ctx, p) {
 	const notes = bottlesOf(ctx.data.reflections, p.id);
@@ -18466,7 +18696,7 @@ const HARBOR_TOOLS = [
 	tool({
 		name: "get_project",
 		title: "Project details",
-		description: "One project: health and why, dates, budget, task counts, late tasks, what it waits on, milestones and open risks, when it will likely finish at the crew's recent pace (finish: shortHistory when there's under two weeks of it; lastDue names the open task whose due date the dates wait for, when the pace alone would finish sooner), notes the crew left for later (notesForLater: a sealed one shows only who left it and what opens it, unless it's the person's own), and its url on the website." + DATA_NOTE,
+		description: "One project: health and why, dates, budget, task counts, late tasks, what it waits on, milestones and open risks, when it will likely finish at the crew's recent pace (finish: shortHistory when there's under two weeks of it; lastDue names the open task whose due date the dates wait for, when the pace alone would finish sooner), notes the crew left for later (notesForLater: a sealed one shows only who left it and what opens it, unless it's the person's own), its charter (why, in, out, doneWhen, callsBy; null until someone writes one, and outOfScope lists open tasks whose titles name something it leaves out), and its url on the website." + DATA_NOTE,
 		input: object({
 			harbor: harborArg,
 			project: string().min(1).max(200).describe("Project id or name.")
@@ -18526,6 +18756,7 @@ const HARBOR_TOOLS = [
 				milestones,
 				openRaid: raid,
 				finish: finishForecast(p, tasks, ctx.now, spendEntriesOf(data, p.id), data.reflections),
+				...charterOf(p, tasks),
 				...notesOf(ctx, p),
 				...hillOf(p, today),
 				...webLink(ctx, { project: p.id })
@@ -18844,7 +19075,7 @@ const HARBOR_TOOLS = [
 	tool({
 		name: "program_review",
 		title: "The review",
-		description: "The website's Review: programs worst health first, then soonest end, each with its lead, end date, health (and the note when set by hand), late tasks, where it sits on the priority matrix and its next move. Done programs only with includeDone." + DATA_NOTE,
+		description: "The website's Review: programs worst health first, then soonest end, each with its lead, end date, health (and the note when set by hand), late tasks, where it sits on the priority matrix and its next move. Done programs only with includeDone. blankCharters lists running projects in them whose charter is still empty a week after they started (set_charter writes one)." + DATA_NOTE,
 		input: object({
 			harbor: harborArg,
 			owner: string().max(200).optional().describe("\"me\", or a person's id or name: programs they lead, lead a project in or hold a task in."),
@@ -18881,6 +19112,11 @@ const HARBOR_TOOLS = [
 					nextMove: p.nextMove?.trim() || null
 				})),
 				done: all.length - listed.length,
+				blankCharters: blankCharters(data, listed, todayISO(ctx.now)).map((b) => ({
+					project: b.project.name,
+					program: data.programs.find((x) => x.id === b.project.programId)?.name ?? null,
+					startedDaysAgo: b.days
+				})),
 				onlyOneKnows: lifeboats(data, ctx.now, { programIds: new Set(listed.map((p) => p.id)) }).slice(0, 25).map((l) => lifeboatOut(data, l, people))
 			};
 		}
@@ -18964,6 +19200,17 @@ const HARBOR_TOOLS = [
 					cameTrue: r.happened,
 					...r.guessed ? { guessed: true } : {}
 				})),
+				...log.charter ? { charter: {
+					doneWhen: log.charter.doneWhen,
+					inItems: log.charter.delivered.map((d) => ({
+						item: d.item,
+						finishedTasks: d.done
+					})),
+					outOfScopeTasks: log.charter.crept.map((c) => ({
+						title: c.task.title,
+						names: c.item
+					}))
+				} } : {},
 				decisions: log.decisions.map((d) => ({
 					title: d.title,
 					on: dayOf(d.decidedAt),
@@ -19223,8 +19470,10 @@ const HARBOR_TOOLS = [
 			const program = input.program ? findOne(data.programs, input.program, "program") : null;
 			const lines = lifeboats(data, ctx.now, { programIds: program ? /* @__PURE__ */ new Set([program.id]) : null });
 			const people = byId(data.people);
+			const alone = data.people.filter((p) => !isAgent(p)).length <= 1;
 			return {
 				...program ? { program: program.name } : {},
+				...alone && lines.length > 0 ? { hint: LIFEBOATS_ALONE } : {},
 				count: lines.length,
 				lines: lines.slice(input.offset, input.offset + input.limit).map((l) => lifeboatOut(data, l, people)),
 				away: awayNote(data, lines, todayISO(ctx.now)),
@@ -20226,6 +20475,13 @@ function hierarchySlice({ get, write }) {
 				hillMovedAt: stamp()
 			} : p) });
 		},
+		setCharter: (projectId, patch) => {
+			const by = get().currentUserId;
+			write({ projects: get().projects.map((p) => p.id === projectId ? {
+				...p,
+				charter: withCharter(p.charter, patch, by, stamp())
+			} : p) });
+		},
 		addCustomField: (projectId, def) => {
 			const id = uid("cf");
 			write({ projects: get().projects.map((p) => p.id === projectId ? {
@@ -20502,6 +20758,7 @@ var init_hierarchy = __esmMin((() => {
 	init_derived_health();
 	init_shared();
 	init_hill();
+	init_charter_lines();
 	init_sample_project();
 	init_format();
 	init_empty();
@@ -25611,6 +25868,7 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 		reflections,
 		raidItems
 	}, project, clockNow(), day);
+	const charter = charterNote(project, tasks, day);
 	const opened = freshlyOpened({
 		reflections,
 		milestones
@@ -25699,6 +25957,10 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 					pmNote ? /* @__PURE__ */ jsxs(Text, {
 						color: theme.muted,
 						children: [" · ", pmNote]
+					}) : null,
+					charter ? /* @__PURE__ */ jsxs(Text, {
+						color: charter.warn ? theme.warn : theme.muted,
+						children: [" · ", charter.text]
 					}) : null
 				]
 			}),
@@ -28122,7 +28384,7 @@ async function pickHarbor(deps) {
 //#endregion
 //#region src/tui/fog-sweep.ts
 /**
-* `harbor fog` in a terminal: the tasks nobody has touched for three weeks
+* `harbor fog --sweep` 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.
@@ -28209,6 +28471,192 @@ function fogSummary(t) {
 	return parts.length ? `${parts.join(", ")}.` : "Nothing changed.";
 }
 
+//#endregion
+//#region src/tui/watch.ts
+init_indexes();
+init_swatches();
+/** Most lines one change prints; a whole reload says how many more there were. */
+const WATCH_MAX = 12;
+const QUOTE_MAX = 90;
+function firstWords(body) {
+	const one = body.replace(/\s+/g, " ").trim();
+	return one.length > QUOTE_MAX ? `${one.slice(0, 89)}…` : one;
+}
+function firstName(p) {
+	return p?.name.split(" ")[0] || "Someone";
+}
+function watchLines(prev, next, meId) {
+	const out = [];
+	const people = byId(next.people);
+	const before = byId(prev.tasks);
+	const label = (t) => `${keyOf$1(next, t)} ${t.title}`;
+	const seen = new Set(prev.activity.map((a) => a.id));
+	const fresh = next.activity.filter((a) => !seen.has(a.id));
+	const who = (t) => {
+		const hit = fresh.find((a) => a.text.includes(`“${t.title}”`));
+		if (!hit) return null;
+		return hit.personId === meId ? "You" : firstName(people.get(hit.personId));
+	};
+	const said = (t, phrase) => {
+		const name = who(t);
+		return name ? `${name} ${phrase}` : phrase.charAt(0).toUpperCase() + phrase.slice(1);
+	};
+	for (const t of next.tasks) {
+		const was = before.get(t.id);
+		const mine = t.assigneeId === meId;
+		if (!was) {
+			const name = who(t);
+			out.push({
+				text: mine && name !== "You" ? `${name ?? "Someone"} added ${label(t)} for you` : `${name ?? "Someone"} added ${label(t)}`,
+				mine,
+				tone: "plain"
+			});
+			continue;
+		}
+		if (t.assigneeId !== was.assigneeId && mine) {
+			const from = t.assignedBy && t.assignedBy !== meId ? firstName(people.get(t.assignedBy)) : null;
+			out.push({
+				text: `You were handed ${label(t)}${from ? ` by ${from}` : ""}`,
+				mine: true,
+				tone: "good"
+			});
+		} else if (t.assigneeId !== was.assigneeId && was.assigneeId === meId) {
+			const to = t.assigneeId ? firstName(people.get(t.assigneeId)) : "nobody";
+			out.push({
+				text: `Your task ${label(t)} went to ${to}`,
+				mine: true,
+				tone: "warn"
+			});
+		}
+		if (t.status !== was.status) {
+			const done = t.status === "done";
+			out.push({
+				text: done ? said(t, `finished ${label(t)}`) : said(t, `moved ${label(t)} to ${TASK_STATUS_LABEL[t.status]}`),
+				mine,
+				tone: done ? "good" : "plain"
+			});
+		} else if (t.dueDate !== was.dueDate && mine) out.push({
+			text: t.dueDate ? `${label(t)} is due ${t.dueDate} now` : `${label(t)} has no due date now`,
+			mine: true,
+			tone: "plain"
+		});
+	}
+	for (const t of prev.tasks) {
+		if (next.tasks.some((x) => x.id === t.id)) continue;
+		out.push({
+			text: `${label(t)} was removed`,
+			mine: t.assigneeId === meId,
+			tone: "warn"
+		});
+	}
+	const oldComments = new Set(prev.comments.map((c) => c.id));
+	const tasks = byId(next.tasks);
+	for (const c of next.comments) {
+		if (oldComments.has(c.id)) continue;
+		const t = tasks.get(c.taskId);
+		if (!t) continue;
+		const yours = t.assigneeId === meId;
+		const mentioned = c.mentionedIds.includes(meId);
+		const name = c.authorId === meId ? "You" : firstName(people.get(c.authorId));
+		out.push({
+			text: mentioned ? `${name} mentioned you on ${label(t)}` : `${name} commented on ${yours && name !== "You" ? "your task " : ""}${label(t)}`,
+			quote: firstWords(c.body),
+			mine: (yours || mentioned) && c.authorId !== meId,
+			tone: mentioned ? "warn" : "plain"
+		});
+	}
+	const health = (kind) => {
+		const was = byId(prev[kind]);
+		for (const item of next[kind]) {
+			const old = was.get(item.id);
+			if (!old || old.health === item.health) continue;
+			out.push({
+				text: `${item.name}: ${HEALTH_LABEL$1[old.health]} → ${HEALTH_LABEL$1[item.health]}`,
+				mine: item.ownerId === meId,
+				tone: item.health === "off-track" ? "bad" : item.health === "at-risk" ? "warn" : item.health === "on-track" || item.health === "done" ? "good" : "plain"
+			});
+		}
+	};
+	health("programs");
+	health("projects");
+	if (out.length > 12) {
+		const more = out.length - 11;
+		return [...out.slice(0, 11), {
+			text: `and ${more} more changes`,
+			mine: false,
+			tone: "plain"
+		}];
+	}
+	return out;
+}
+
+//#endregion
+//#region src/tui/watch-run.ts
+init_clock();
+init_plain();
+init_repo_sync();
+init_store();
+init_sync();
+const ANSI = {
+	dim: "\x1B[2m",
+	bold: "\x1B[1m",
+	reset: "\x1B[0m",
+	good: "\x1B[36m",
+	warn: "\x1B[33m",
+	bad: "\x1B[31m"
+};
+/** One ticker line for the terminal: the time dim, the rest bright when it's yours. */
+function watchText(line, at, opts) {
+	const time = wallClock(at).slice(11, 16);
+	const room = (opts.width ?? 0) - 6;
+	const fit = (s, n) => opts.width && s.length > n ? `${s.slice(0, Math.max(1, n - 1))}…` : s;
+	const text = fit(line.text, room);
+	const quote = line.quote ? fit(`“${line.quote}”`, room - 2) : null;
+	if (!opts.colour) return [`${time} ${text}`, ...quote ? [`        ${quote}`] : []].join("\n");
+	const tone = line.tone === "plain" ? "" : ANSI[line.tone];
+	const body = line.mine ? `${ANSI.bold}${tone}${text}${ANSI.reset}` : `${tone || ANSI.dim}${text}${ANSI.reset}`;
+	return [`${ANSI.dim}${time}${ANSI.reset} ${body}`, ...quote ? [`${ANSI.dim}        ${quote}${ANSI.reset}`] : []].join("\n");
+}
+async function watchOn(opts) {
+	const out = (text) => opts.write(`${text}\n`);
+	const store = createAppStore();
+	const sync = createSync({
+		store,
+		transport: opts.transport,
+		account: {
+			id: opts.account.id,
+			name: opts.account.name || opts.account.email
+		},
+		onNotice: (n) => out(plain(n))
+	});
+	await sync.open(opts.harbor.id);
+	try {
+		const project = opts.project ? projectNamed(store.getState().projects, opts.project) : null;
+		const dim = (s) => opts.colour ? `${ANSI.dim}${s}${ANSI.reset}` : s;
+		out(dim(`⚓ ${plain(opts.harbor.name)}${project ? ` · ${plain(project.name)}` : ""} · on watch${opts.bell ? " · bell on" : ""} · q to stop`));
+		const narrow = (d) => project ? {
+			...d,
+			tasks: d.tasks.filter((t) => t.projectId === project.id),
+			projects: d.projects.filter((p) => p.id === project.id),
+			programs: []
+		} : d;
+		const unsubscribe = store.subscribe((s, prev) => {
+			if (s.tasks === prev.tasks && s.comments === prev.comments && s.projects === prev.projects && s.programs === prev.programs) return;
+			const lines = watchLines(narrow(prev), narrow(s), s.currentUserId);
+			const at = opts.now?.() ?? /* @__PURE__ */ new Date();
+			for (const line of lines) out(watchText(line, at, {
+				colour: opts.colour,
+				width: opts.width?.()
+			}));
+			if (opts.bell && lines.some((l) => l.mine)) opts.write("\x07");
+		});
+		await opts.stopped;
+		unsubscribe();
+	} finally {
+		sync.close();
+	}
+}
+
 //#endregion
 //#region src/repo/folder.ts
 /**
@@ -28597,7 +29045,7 @@ function harborFor(harbors, named, saved) {
 	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. */
+/** `harbor fog --sweep`: 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();
@@ -28633,7 +29081,45 @@ async function fogHere(opts) {
 		await sync.flush();
 		sync.close();
 	}
-	if (sync.state !== "saved") throw new HarborError("Harbor didn't take those answers. Run harbor fog again.");
+	if (sync.state !== "saved") throw new HarborError("Harbor didn't take those answers. Run harbor fog --sweep again.");
+}
+/**
+* `harbor watch`: the harbor's changes as they land, a line each, until q
+* or Ctrl+C. Nothing is changed from here; it only listens.
+*/
+async function watchHere(opts) {
+	const transport = plainTransport(httpTransport(opts.source, opts.fetcher));
+	const answer = await transport.harbors();
+	const harbor = harborFor(answer.harbors, opts.harbor, opts.saved);
+	const stopped = new Promise((resolve) => {
+		const input = process.stdin;
+		const stop = () => {
+			input.off("data", onKey);
+			process.off("SIGINT", stop);
+			if (input.isTTY) input.setRawMode(false);
+			input.pause();
+			resolve();
+		};
+		const onKey = (chunk) => {
+			const key = chunk.toString();
+			if (key === "q" || key === "Q" || key === "") stop();
+		};
+		if (input.isTTY) input.setRawMode(true);
+		input.on("data", onKey);
+		input.resume();
+		process.on("SIGINT", stop);
+	});
+	await watchOn({
+		transport,
+		account: answer.account,
+		harbor,
+		project: opts.project,
+		bell: opts.bell,
+		colour: opts.colour,
+		width: () => process.stdout.columns,
+		write: (text) => process.stdout.write(text),
+		stopped
+	});
 }
 /** Questions asked on the plain terminal, before the app takes it over. Ctrl+C stops. */
 function terminalAsk(stoppedText = "Stopped. Nothing was made.") {
@@ -28676,4 +29162,4 @@ function planTransport(source, fetcher) {
 }
 
 //#endregion
-export { SPLASH_MS, TransportError, firstHarbor, fogHere, 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, watchHere };

package/lib/cli.mjs

@@ -33,6 +33,7 @@ import {
   myWork,
   premortemText,
   notesText,
+  charterText,
   daysText,
   soundingText,
   lifeboatsText,
@@ -205,6 +206,10 @@ export const HELP = `harbor: Harbor from the terminal
                                               answer or read it
   harbor voyage PROJECT ["YOUR LINE"]         a Done project's voyage log, and
                                               your line in it
+  harbor charter PROJECT [--why T] [--in T] [--out T] [--done-when T]
+                         [--calls T]
+                                              a project's five-line charter:
+                                              read it, or write some lines
   harbor note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]
                                               a note for later: sealed until
                                               its day, milestone, or Off track
@@ -218,10 +223,13 @@ export const HELP = `harbor: Harbor from the terminal
                          [--keep ID,ID] [--confirm]
                                               hand someone's work to the crew
   harbor handback PERSON                      give it back after time away
-  harbor fog [--project P] [--list]           tasks nobody has touched for three
-                                              weeks, one at a time: still
-                                              needed, a new date, or drop it
+  harbor fog [--project P]                    tasks nobody has touched for three
+                                              weeks, longest first
+  harbor fog --sweep [--project P]            one at a time: still needed, a
+                                              new date, or drop it
   harbor fog keep TASK                        it's still needed: out of the fog
+  harbor watch [--project P] [--bell]         a live ticker of the harbor's
+                                              changes; yours bright, q stops
   harbor lifeboats [--program P]              work only one person knows, each
                                               with a second pair of hands
   harbor lifeboats N [--person NAME]          adds that second pair of hands
@@ -239,7 +247,7 @@ export const HELP = `harbor: Harbor from the terminal
   DATE: YYYY-MM-DD, today, tomorrow, or +N for N days from today.
   Changes show in Harbor's History as yours, "via Harbor CLI". These commands
   never delete; the full-screen app can, as the website can, and asks first,
-  and so can harbor fog's x (drop it), one task at a time.
+  and so can harbor fog --sweep's x (drop it), one task at a time.
 `;
 
 export const VERSION = JSON.parse(
@@ -423,6 +431,10 @@ const FLAG = {
   text: "the next move",
   waitsOn: "--waits-on",
   repeat: "--repeat",
+  in: "--in",
+  out: "--out",
+  doneWhen: "--done-when",
+  callsBy: "--calls",
   description: "--notes",
   body: "the comment",
   column: "the column",
@@ -701,6 +713,18 @@ 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.",
   ],
+  charter: [
+    "  harbor charter PROJECT                 reads its charter, and any open task",
+    "                                         that names something it leaves out",
+    '  harbor charter PROJECT --why "TEXT"    writes: that line; give any of',
+    "                                         --why, --in, --out, --done-when and",
+    "                                         --calls at once",
+    "",
+    "  none clears a line: --out none. Separate items in --in and --out",
+    "  with commas, so Harbor can spot a task that names one. The review lists",
+    "  running projects still without a charter a week after they started.",
+    "  PROJECT is a name, a key like RR, or an id.",
+  ],
   sound: [
     "  harbor sound TASK                      reads its sounding: who hasn't answered,",
     "                                         and the spread once everyone has",
@@ -749,18 +773,29 @@ const DETAIL = {
     '  PERSON is a name, an id, or "me".',
   ],
   fog: [
-    "  harbor fog [--project P]               in a terminal: the tasks in fog, one",
+    "  harbor fog [--project P]               reads them: open tasks nobody has",
+    "                                         opened, moved, edited or commented on",
+    "                                         for three weeks, longest first",
+    "  harbor fog --sweep [--project P]       in a terminal: the tasks in fog, one",
     "                                         at a time. k still needed (clears the",
     "                                         fog), d a new date, x drop it, s skip,",
     "                                         q stop; then it saves what you chose",
-    "  harbor fog --list                      reads them: open tasks nobody has",
-    "                                         opened, moved, edited or commented on",
-    "                                         for three weeks, longest first",
     "  harbor fog keep TASK                   writes: it's still needed, so it",
     "                                         leaves the fog",
     "",
-    "  Piped, or with --json, it lists. The one-at-a-time sweep needs full access",
-    "  (harbor login without --read-only), since dropping a task deletes it.",
+    "  The sweep needs a terminal and full access (harbor login without",
+    "  --read-only), since dropping a task deletes it.",
+  ],
+  watch: [
+    "  harbor watch                           reads, live: each change to the harbor",
+    "                                         as it lands, one line with the time:",
+    "                                         cards moving, comments, health changes",
+    "    --project P     one project's changes only",
+    "    --bell          ring the terminal's bell when something of yours changes",
+    "",
+    "  Lines about your own work (your tasks, mentions of you, what you lead) are",
+    "  bright; the rest are dim. q or Ctrl+C stops. Made for a narrow split or a",
+    "  tmux pane; it needs full access (harbor login without --read-only).",
   ],
   lifeboats: [
     "  harbor lifeboats [--program P]         reads: work only one person has",
@@ -842,7 +877,7 @@ const DETAIL = {
     '  harbor raid "TITLE" --update "TEXT"    writes: adds a line to its updates',
     '  harbor raid "TITLE" --still-stands "WHY"',
     "                                         writes: a decision looked at again",
-    "                                         still stands (\"\" for no reason);",
+    '                                         still stands ("" for no reason);',
     "                                         clears its look again",
     "",
     "  Also --owner me|none|NAME, --impact 1-5, --probability 1-5 (risks),",
@@ -2083,7 +2118,13 @@ export async function run(argv, io = {}) {
             words && r.programs.length === 0
               ? `No program in the review matches "${words}".`
               : reviewList(r),
-          (r) => (words ? { ...r, programs: r.programs.filter((p) => nameHas(p.name, words)) } : r),
+          (r) => {
+            if (!words) return r;
+            const programs = r.programs.filter((p) => nameHas(p.name, words));
+            const names = new Set(programs.map((p) => p.name));
+            const blankCharters = (r.blankCharters ?? []).filter((b) => names.has(b.program));
+            return { ...r, programs, blankCharters };
+          },
         );
       }
       const status = { start: "doing", submit: "review", done: "done" }[command];
@@ -2405,6 +2446,44 @@ export async function run(argv, io = {}) {
         (r) => `Sealed your note on ${r.sealed.project}. It ${r.sealed.opens}.`,
       );
     }
+    case "charter": {
+      const { positionals, values, harbor } = parse(
+        spec([], ["why", "in", "out", "done-when", "calls"]),
+      );
+      const project = one(positionals, 'project: harbor charter "NAME"');
+      // none clears a line, as --due none does.
+      const line = (v) => (v.trim().toLowerCase() === "none" ? "" : v);
+      const lines = Object.fromEntries(
+        [
+          ["why", values.why],
+          ["in", values.in],
+          ["out", values.out],
+          ["doneWhen", values["done-when"]],
+          ["callsBy", values.calls],
+        ]
+          .filter(([, v]) => v !== undefined)
+          .map(([k, v]) => [k, line(v)]),
+      );
+      if (Object.keys(lines).length === 0) {
+        // --json: the project's charter (null until written) and any out-of-scope tasks.
+        return call(
+          "get_project",
+          { harbor, project },
+          (r) => charterText(r),
+          (r) => ({
+            id: r.id,
+            project: r.name,
+            charter: r.charter ?? null,
+            ...(r.outOfScope ? { outOfScope: r.outOfScope } : {}),
+          }),
+        );
+      }
+      return call("set_charter", { harbor, project, ...lines }, (r) =>
+        r.charter
+          ? `Saved ${r.project}'s charter.\n\n${charterText({ project: r.project, charter: r.charter })}`
+          : `Cleared ${r.project}'s charter.`,
+      );
+    }
     case "sound": {
       const { positionals, values, harbor } = parse(spec([], ["why", "ask", "settle"]));
       const [task, days, ...extra] = positionals;
@@ -2484,8 +2563,27 @@ export async function run(argv, io = {}) {
       }
       return call("get_voyage_log", { harbor, project }, voyageText, voyageForTerminal);
     }
+    case "watch": {
+      const { positionals, values, harbor } = parse(spec(["bell"], ["project"]));
+      none(positionals);
+      if (!hasFullAccess(creds))
+        throw new HarborError(
+          "Watching needs full access, as the full-screen app does. Run harbor login (without --read-only), then try again.",
+        );
+      const { watchHere } = await loadApp();
+      await watchHere({
+        source: tokenSource({ creds, save: (c) => writeCredentials(c, env), fetcher }),
+        fetcher,
+        harbor,
+        saved: creds.harbor ?? null,
+        project: values.project,
+        bell: Boolean(values.bell),
+        colour: colourDepth(io.stdout ?? process.stdout, env) !== "none",
+      });
+      return 0;
+    }
     case "fog": {
-      const { positionals, values, harbor } = parse(spec(["list"], ["project"]));
+      const { positionals, values, harbor } = parse(spec(["list", "sweep"], ["project"]));
       if (positionals[0] === "keep") {
         const task = one(positionals.slice(1), "task");
         return call(
@@ -2495,8 +2593,17 @@ export async function run(argv, io = {}) {
         );
       }
       none(positionals);
-      const terminal = io.terminal ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
-      if (terminal && !values.list && !asJson && hasFullAccess(creds)) {
+      // Listing is the default; the sweep, where x deletes, only when asked for.
+      if (values.sweep) {
+        const terminal = io.terminal ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+        if (!terminal || asJson) {
+          throw new HarborError("harbor fog --sweep asks about each task, so it needs a terminal.");
+        }
+        if (!hasFullAccess(creds)) {
+          throw new HarborError(
+            "harbor fog --sweep can drop tasks, so it needs full access: harbor login (without --read-only).",
+          );
+        }
         const { fogHere } = await loadApp();
         await fogHere({
           source: tokenSource({ creds, save: (c) => writeCredentials(c, env), fetcher }),

package/lib/format.mjs

@@ -344,6 +344,14 @@ export function reviewList(r) {
     out.push(`${p.name}  (${bits.join(" · ")})`);
     out.push(`  ${p.nextMove ? `next: ${p.nextMove}` : "no next move yet"}`);
   }
+  const blank = r.blankCharters ?? [];
+  if (blank.length) {
+    out.push("", "Charters still blank a week in:");
+    for (const b of blank.slice(0, 8))
+      out.push(`  ${b.project}  (started ${b.startedDaysAgo} days ago)`);
+    if (blank.length > 8) out.push(`  and ${blank.length - 8} more`);
+    out.push('  harbor charter "PROJECT" --why "…" writes one.');
+  }
   return out.join("\n") + more;
 }
 
@@ -531,7 +539,10 @@ export function voyageText(r) {
 
 /** What's holding something up, as long_pole answers it: the headline, then the line of waits, first blocker at the top. */
 export function whyText(r) {
-  const what = r.of.kind === "task" ? r.of.name : `${r.of.name}${r.of.kind === "milestone" ? " (milestone)" : ""}`;
+  const what =
+    r.of.kind === "task"
+      ? r.of.name
+      : `${r.of.name}${r.of.kind === "milestone" ? " (milestone)" : ""}`;
   if (r.none) return `What's holding up ${what}: ${r.none.replace(/^\w/, (c) => c.toLowerCase())}`;
   const head = [`What's holding up ${what}`];
   if (r.headline) head.push(r.headline);
@@ -544,14 +555,19 @@ export function whyText(r) {
       `  ${(l.key ?? "").padEnd(width)}${width ? "  " : ""}${l.title}`,
       `  ${" ".repeat(width)}${width ? "  " : ""}${l.assignee ?? "nobody yet"} · ${due}${finish} · ${l.slackText}`,
     ];
-    return i < chain.length - 1 ? [...row, `  ${" ".repeat(width ? Math.floor(width / 2) : 0)}│`] : row;
+    return i < chain.length - 1
+      ? [...row, `  ${" ".repeat(width ? Math.floor(width / 2) : 0)}│`]
+      : row;
   });
   const via = r.via ? [`It waits longest on ${r.via.project}; inside it:`] : [];
   const others = (r.others ?? []).length
     ? [
         "",
         `Also waits on ${r.others
-          .map((o) => `${o.project} (finishes ${o.finish}, ${o.slack >= 0 ? `${o.slack} day${o.slack === 1 ? "" : "s"} spare` : `${-o.slack} day${o.slack === -1 ? "" : "s"} over`})`)
+          .map(
+            (o) =>
+              `${o.project} (finishes ${o.finish}, ${o.slack >= 0 ? `${o.slack} day${o.slack === 1 ? "" : "s"} spare` : `${-o.slack} day${o.slack === -1 ? "" : "s"} over`})`,
+          )
           .join(", ")}.`,
       ]
     : [];
@@ -650,6 +666,36 @@ export function importText(r) {
 }
 
 /** A project's notes for later, as get_project lists them. */
+const CHARTER_LINES = [
+  ["why", "Why"],
+  ["in", "In"],
+  ["out", "Out"],
+  ["doneWhen", "Done when"],
+  ["callsBy", "Calls made by"],
+];
+
+/** A project's charter as get_project or set_charter gives it, with open tasks that name what it leaves out. */
+export function charterText(r) {
+  const project = r.name ?? r.project;
+  if (!r.charter) {
+    return `${project} has no charter yet. Write one, a line at a time:\n  harbor charter "${project}" --why "…" --in "…, …" --out "…, …" --done-when "…" --calls "…"`;
+  }
+  const lines = [`Charter · ${project}`];
+  const width = Math.max(...CHARTER_LINES.map(([, label]) => label.length));
+  for (const [key, label] of CHARTER_LINES) {
+    if (r.charter[key]) lines.push(`  ${label.padEnd(width)}  ${r.charter[key]}`);
+  }
+  if (r.outOfScope?.length) {
+    lines.push("", "Out of scope?");
+    for (const t of r.outOfScope) {
+      lines.push(
+        `  ${t.task}  ${t.title}  (added ${t.added}; the charter leaves out "${t.names}")`,
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
 export function notesText(project, notes) {
   if (!notes?.length)
     return `No notes for later on ${project}. Leave one: harbor note "${project}" "NOTE" --opens +30`;
@@ -923,7 +969,7 @@ export function fogText(r, { sweepHint = true } = {}) {
   if (sweepHint)
     lines.push(
       "",
-      "In a terminal, harbor fog walks through them one at a time: k still needed, d new date, x drop it. harbor fog keep TASK keeps one.",
+      "harbor fog --sweep walks through them one at a time: k still needed, d new date, x drop it. harbor fog keep TASK keeps one.",
     );
   return lines.join("\n");
 }
@@ -945,6 +991,7 @@ export function lifeboatsText(r) {
   });
   if (r.more) lines.push("", `And ${r.count - r.lines.length} more.`);
   for (const a of r.away ?? []) lines.push("", a);
+  if (r.hint) return [...lines, "", r.hint].join("\n");
   lines.push(
     "",
     "harbor lifeboats N adds the suggested second pair of hands (--person NAME for someone else).",

package/package.json

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