@harborppm/cli 0.34.0 → 0.36.0

package/README.md

@@ -128,16 +128,21 @@ harbor brief [--portfolio P] [--say]        the weekly brief, ready to send
 harbor report PROGRAM                       a program's status report
 harbor premortem PROJECT ["WHAT WENT WRONG"] [--start]
 harbor voyage PROJECT ["YOUR LINE"]
+harbor note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]
 harbor limit PROJECT [COLUMN N|none]
 harbor handover PERSON [--to NAME] [--until DATE] [--note TEXT] [--keep ID,ID] [--confirm]
 harbor handback PERSON
+harbor agent [--agent NAME]
+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.
 
+Agents on the crew: put an AI app on People with Add an agent and assign it tasks like anyone else. An agent working through the CLI (Claude Code, say) runs `harbor agent` for its tasks, in progress first, with their notes, checklists and latest comments. When it's done, `harbor agent report RR-4 "Drafted 12 questions; two need Dana"` adds its note as the agent's comment and moves the task to In review for a person to check. An agent never marks its own work Done.
+
 `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 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 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).
 

package/dist/app.mjs

@@ -3524,6 +3524,123 @@ function programLateCount(programId, data, now) {
 	return late;
 }
 
+//#endregion
+//#region src/lib/bottle-rules.ts
+/**
+* What a note for later needs before it's sealed (the rest is in bottle.ts).
+* Apart so the store's action carries only this into every page's first load.
+*/
+/** Longest note kept. */
+const BOTTLE_MAX = 1e3;
+/**
+* Why a new note can't be sealed, or null when it can: nothing written, a
+* date that isn't after today (it would open at once), or a milestone that
+* isn't this project's program's or is already reached.
+*/
+function bottleProblem(body, opens, ctx) {
+	if (!body.trim()) return "Write the note first.";
+	if (opens.on === "date") {
+		if (!/^\d{4}-\d{2}-\d{2}$/.test(opens.date)) return "Pick the day it opens.";
+		if (opens.date <= todayISO(ctx.now)) return "Pick a day after today.";
+	}
+	if (opens.on === "milestone") {
+		const m = ctx.milestones.find((x) => x.id === opens.milestoneId);
+		if (!m || m.programId !== ctx.programId) return "Pick one of this program's milestones.";
+		if (m.done) return `${m.name} is already reached.`;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/lib/bottle.ts
+/**
+* Message in a bottle: a note someone leaves on a project now that opens
+* later, on a date, when one of the program's milestones is reached, or if
+* the project turns Off track. Until then the crew sees only that a sealed
+* note is there, who left it and what opens it; the writer can read their
+* own. Once open it sits at the top of the project and in the brief.
+*
+* Notes are `reflections` of kind "bottle". Whether one is open is worked
+* out from the project as it stands (nothing stamps it), so every screen,
+* the CLI and the agents agree. Like the pre-mortem's wait, the seal is a
+* courtesy the screens keep, not a secret from the server.
+*/
+/** An opened note stays at the top of its project this many days, then folds away. */
+const BOTTLE_FRESH_DAYS = 14;
+const isBottle = (r) => r.kind === "bottle";
+/**
+* Whether a note is open, and since when. A date opens it that morning; a
+* milestone when it's marked done (dated by its due date, or today if that's
+* still ahead); Off track the first time the project went Off track after
+* the note was left. A milestone since deleted opens it, so nothing is
+* sealed for good.
+*/
+function bottleState(note, ctx) {
+	const today = todayISO(ctx.now);
+	const opens = note.opens;
+	if (!opens) return {
+		open: true,
+		openedOn: note.createdAt.slice(0, 10)
+	};
+	if (opens.on === "date") return today >= opens.date ? {
+		open: true,
+		openedOn: opens.date
+	} : sealed;
+	if (opens.on === "milestone") {
+		const m = ctx.milestones.find((x) => x.id === opens.milestoneId);
+		if (!m) return {
+			open: true,
+			openedOn: today
+		};
+		if (!m.done) return sealed;
+		return {
+			open: true,
+			openedOn: m.dueDate && m.dueDate < today ? m.dueDate : today
+		};
+	}
+	const flip = (ctx.project.healthHistory ?? []).find((h) => h.health === "off-track" && h.at >= note.createdAt);
+	if (flip) return {
+		open: true,
+		openedOn: flip.at.slice(0, 10)
+	};
+	if (ctx.project.health === "off-track") return {
+		open: true,
+		openedOn: today
+	};
+	return sealed;
+}
+const sealed = {
+	open: false,
+	openedOn: null
+};
+/** Opened in the last `days` days, so it still belongs at the top and in the brief. */
+function isFresh(state, now, days = 14) {
+	if (!state.open || !state.openedOn) return false;
+	return differenceInCalendarDays(now, parseIso(state.openedOn)) < days;
+}
+/** Notes opened in the last fortnight across these projects, newest first: the brief's. */
+function freshlyOpened(data, projects, now) {
+	const notes = (data.reflections ?? []).filter(isBottle);
+	if (notes.length === 0) return [];
+	const byProject = new Map(projects.map((p) => [p.id, p]));
+	const out = [];
+	for (const note of notes) {
+		const project = byProject.get(note.projectId);
+		if (!project) continue;
+		const state = bottleState(note, {
+			project,
+			milestones: data.milestones,
+			now
+		});
+		if (isFresh(state, now)) out.push({
+			note,
+			project,
+			state
+		});
+	}
+	return out.sort((a, b) => (b.state.openedOn ?? "").localeCompare(a.state.openedOn ?? ""));
+}
+
 //#endregion
 //#region src/lib/brief.ts
 const BRIEF_QUIET = "Nothing late or at risk. Say what shipped — or enjoy the quiet week.";
@@ -3618,6 +3735,14 @@ function composeBriefBody(opts) {
 	const lateMilestones = milestones.filter((m) => m.daysLate > 0);
 	const quiet = opts.offTrack.length === 0 && opts.atRisk.length === 0 && opts.late.length === 0 && watch.length === 0 && lateMilestones.length === 0;
 	const lines = [`Harbor brief — ${opts.workspace} — ${date}`, ""];
+	if (opts.opened?.length) {
+		lines.push("Notes that opened");
+		for (const n of opts.opened) {
+			const body = n.body.replace(/\s+/g, " ").trim();
+			lines.push(`• ${n.project}${n.who ? `, from ${n.who}` : ""}: “${body}”`);
+		}
+		lines.push("");
+	}
 	const done = () => {
 		if (!opts.shipped?.length) return;
 		lines.push("Done this week");
@@ -3861,6 +3986,7 @@ function briefOf(data, opts = {}) {
 		finished,
 		said: saidThisWeek(data, now, portfolioId ? new Set(tasks.flatMap((t) => t.assigneeId ? [t.assigneeId] : [])) : null),
 		late: lateLinesOf(data, tasks, now),
+		opened: freshlyOpened(data, projects, now),
 		talk,
 		milestonesSoon,
 		milestonesLate,
@@ -3906,6 +4032,11 @@ function composeBriefBodyFrom(brief, data, workspace) {
 			program: data.programs.find((p) => p.id === m.programId)?.name ?? null,
 			dueDate: m.dueDate,
 			daysLate: -daysUntil(m.dueDate, brief.asOf)
+		})),
+		opened: brief.opened.map((b) => ({
+			project: b.project.name,
+			who: data.people.find((p) => p.id === b.note.authorId)?.name ?? null,
+			body: b.note.body
 		}))
 	});
 }
@@ -7757,6 +7888,8 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 	const projects = useHarbor((s) => s.projects);
 	const people = useHarbor((s) => s.people);
 	const boardConfigs = useHarbor((s) => s.boardConfigs);
+	const reflections = useHarbor((s) => s.reflections);
+	const milestones = useHarbor((s) => s.milestones);
 	const project = projects.find((p) => p.id === projectId);
 	const data = useMemo(() => ({
 		tasks,
@@ -7893,7 +8026,12 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 	const tide = tideLine(data, project, day);
 	const filtered = [filter.who === "none" ? "nobody's" : filter.who !== "any" ? `${people.find((p) => p.id === filter.who)?.name ?? "someone"}'s` : null, filter.priority !== "any" ? PRIORITY_LABEL[filter.priority].toLowerCase() : null].filter(Boolean);
 	const lead = people.find((p) => p.id === project.ownerId);
-	const body = height - 3;
+	const opened = freshlyOpened({
+		reflections,
+		milestones
+	}, [project], /* @__PURE__ */ new Date(`${day}T12:00:00`))[0];
+	const openedBy = opened ? people.find((p) => p.id === opened.note.authorId)?.name : null;
+	const body = height - 3 - (opened ? 1 : 0);
 	const fit = Math.max(1, Math.floor((width - 2) / 14));
 	const firstColumn = Math.min(Math.max(0, col - Math.floor(fit / 2)), Math.max(0, columns.length - fit));
 	const shownColumns = columns.slice(firstColumn, firstColumn + fit);
@@ -7968,6 +8106,21 @@ function ProjectView({ projectId, active, width, height, go, onBack }) {
 					]
 				})]
 			}),
+			opened && /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				color: theme.warn,
+				children: [
+					"A note opened",
+					openedBy ? `, from ${openedBy}` : "",
+					":",
+					" ",
+					/* @__PURE__ */ jsxs(Text, { children: [
+						"“",
+						opened.note.body.replace(/\s+/g, " "),
+						"”"
+					] })
+				]
+			}),
 			mode === "budget" ? /* @__PURE__ */ jsx(BudgetPane, {
 				project,
 				spendEntries,
@@ -10645,7 +10798,7 @@ function hierarchySlice({ get, write }) {
 			const name = rows.portfolios?.[0]?.name ?? rows.programs?.[0]?.name ?? rows.projects?.[0]?.name;
 			if (name) get().log(`put back “${name}”`);
 		},
-		importRows: (rows) => {
+		importRows: (rows, from = "a spreadsheet") => {
 			const state = get();
 			const have = (current) => new Set(current.map((r) => r.id));
 			const add = (current, more) => {
@@ -10656,10 +10809,11 @@ function hierarchySlice({ get, write }) {
 				programs: add(state.programs, rows.programs),
 				projects: add(state.projects, rows.projects),
 				tasks: add(state.tasks, rows.tasks),
-				people: add(state.people, rows.people)
+				people: add(state.people, rows.people),
+				raidItems: add(state.raidItems, rows.raidItems)
 			});
 			const n = rows.tasks?.length ?? 0;
-			get().log(`imported ${n} task${n === 1 ? "" : "s"} from a spreadsheet`);
+			get().log(`imported ${n} task${n === 1 ? "" : "s"} from ${from}`);
 		},
 		dropRows: (ids) => {
 			const state = get();
@@ -10667,7 +10821,8 @@ function hierarchySlice({ get, write }) {
 				programs: new Set(ids.programs ?? []),
 				projects: new Set(ids.projects ?? []),
 				tasks: new Set(ids.tasks ?? []),
-				people: new Set(ids.people ?? [])
+				people: new Set(ids.people ?? []),
+				raidItems: new Set(ids.raidItems ?? [])
 			};
 			const tasks = state.tasks.filter((r) => !gone.tasks.has(r.id));
 			if (gone.people.size) {
@@ -10678,6 +10833,7 @@ function hierarchySlice({ get, write }) {
 				projects: state.projects.filter((r) => !gone.projects.has(r.id)),
 				tasks,
 				people: gone.people.size ? state.people.filter((r) => !gone.people.has(r.id)) : state.people,
+				raidItems: gone.raidItems.size ? state.raidItems.filter((r) => !gone.raidItems.has(r.id)) : state.raidItems,
 				selectedTaskId: gone.tasks.has(state.selectedTaskId ?? "") ? null : state.selectedTaskId
 			});
 		},
@@ -10995,6 +11151,27 @@ function tasksSlice({ set, get, write }) {
 				else get().log(`commented on “${task.title}”`, `/projects/${task.projectId}`);
 			}
 		},
+		agentUpdate: (agentId, taskId, body, status, opts) => {
+			const task = get().tasks.find((t) => t.id === taskId);
+			const text = body.trim();
+			if (!task || !text) return;
+			if (task.status !== status) get().moveTask(taskId, status, { allowOverCap: opts?.allowOverCap });
+			const at = stamp();
+			write({
+				comments: [...get().comments, {
+					id: uid("c"),
+					taskId,
+					authorId: agentId,
+					body: text,
+					createdAt: at,
+					mentionedIds: parseMentions(text, get().people).filter((id) => id !== agentId)
+				}],
+				people: get().people.map((p) => p.id === agentId ? {
+					...p,
+					lastSeenAt: at
+				} : p)
+			});
+		},
 		updateComment: (id, body) => {
 			const comment = get().comments.find((c) => c.id === id);
 			if (!comment || comment.authorId !== get().currentUserId) return;
@@ -11085,6 +11262,13 @@ function tasksSlice({ set, get, write }) {
 			for (const id of ids) have.add(id);
 			set({ readPingIds: [...have] });
 		},
+		tickVoyage: (ids) => {
+			const tick = new Set(ids);
+			const ticked = get().tasks.filter((t) => tick.has(t.id) && t.status !== "done");
+			if (ticked.length === 0) return;
+			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}`);
+		},
 		toggleFocus: (taskId) => {
 			const personId = get().currentUserId;
 			const date = todayISO();
@@ -11322,13 +11506,36 @@ function milestonesRaidSlice({ set, get, write }) {
 			return row.id;
 		},
 		editReflection: (id, body) => {
-			const text = body.trim().slice(0, 600);
-			if (!text) return;
 			const me = get().currentUserId;
-			write({ reflections: (get().reflections ?? []).map((r) => r.id === id && r.authorId === me ? {
-				...r,
-				body: text
-			} : r) });
+			write({ reflections: (get().reflections ?? []).map((r) => {
+				if (r.id !== id || r.authorId !== me) return r;
+				const text = body.trim().slice(0, r.kind === "bottle" ? BOTTLE_MAX : 600);
+				return text ? {
+					...r,
+					body: text
+				} : r;
+			}) });
+		},
+		leaveBottle: (projectId, body, opens) => {
+			const s = get();
+			const project = s.projects.find((p) => p.id === projectId);
+			if (!project) return null;
+			if (bottleProblem(body, opens, {
+				programId: project.programId,
+				milestones: s.milestones,
+				now: clockNow()
+			})) return null;
+			const row = {
+				id: uid("rf"),
+				projectId,
+				kind: "bottle",
+				authorId: s.currentUserId,
+				body: body.trim().slice(0, BOTTLE_MAX),
+				createdAt: stamp(),
+				opens
+			};
+			write({ reflections: [...s.reflections ?? [], row] });
+			return row.id;
 		},
 		deleteReflection: (id) => {
 			const me = get().currentUserId;
@@ -11512,6 +11719,23 @@ function peopleSpendSlice({ set, get, write }) {
 			get().log(`handed ${person.name}’s work back`, "/people");
 			return applied.moved.length;
 		},
+		addAgent: (a) => {
+			const id = uid("p");
+			const row = {
+				id,
+				name: a.name.trim() || "Claude",
+				role: "Agent",
+				initials: "AI",
+				swatch: a.swatch,
+				location: "",
+				kind: "agent",
+				addedById: get().currentUserId,
+				lastSeenAt: null
+			};
+			set({ people: [...get().people, row] });
+			get().log(`put ${row.name} on the crew as an agent`, "/people");
+			return id;
+		},
 		updatePerson: (id, patch) => {
 			write({ people: get().people.map((p) => p.id === id ? {
 				...p,

package/lib/cli.mjs

@@ -26,8 +26,10 @@ import {
   hillList,
   myWork,
   premortemText,
+  notesText,
   voyageText,
   handoverText,
+  agentWorkText,
   raidList,
   programTree,
   projectList,
@@ -117,10 +119,18 @@ 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 note PROJECT ["NOTE"] [--opens DATE|--milestone NAME|--off-track]
+                                              a note for later: sealed until
+                                              its day, milestone, or Off track
   harbor handover PERSON [--to NAME] [--until DATE] [--note TEXT]
                          [--keep ID,ID] [--confirm]
                                               hand someone's work to the crew
   harbor handback PERSON                      give it back after time away
+  harbor agent [--agent NAME]                 the tasks given to an AI agent on
+                                              the crew, in the order to do them
+  harbor agent report TASK "WHAT YOU DID" [--start] [--agent NAME]
+                                              the agent's note; moves the task
+                                              to In review (--start: doing)
 
   Every command takes --json, and --harbor NAME when you're in more than one
   harbor (or set one with harbor use). harbor help COMMAND shows just that one.
@@ -289,6 +299,8 @@ const FLAG = {
   column: "the column",
   limit: "the limit",
   at: "--at",
+  opensOn: "--opens",
+  milestone: "--milestone",
   until: "--until",
   to: "--to",
   keep: "--keep",
@@ -335,6 +347,10 @@ export function hint(message, project) {
       (_, name) =>
         `${name} has no pre-mortem running. Start one with harbor premortem "${project ?? name}" --start.`,
     )
+    .replace(
+      /^Say what opens the note: exactly one of opensOn, milestone or ifOffTrack\.$/,
+      "Say what opens it: --opens DATE, --milestone NAME or --off-track (one of them).",
+    )
     .replace(
       /^Nothing to change: pass a field to update\.$/,
       "Nothing to change. Say what with --title, --assignee, --due, --priority, --status, --notes, --repeat or --waits-on.",
@@ -396,6 +412,19 @@ const DETAIL = {
     "  PROJECT is a name, a key like RR, or an id. When two projects share a",
     "  name, give the key.",
   ],
+  note: [
+    "  harbor note PROJECT                    reads its notes for later: who left",
+    "                                         each, what opens it, and the opened ones",
+    '  harbor note PROJECT "NOTE" --opens DATE',
+    "                                         writes: seals a note that opens that day",
+    '  harbor note PROJECT "NOTE" --milestone NAME',
+    "                                         writes: opens when that milestone is reached",
+    '  harbor note PROJECT "NOTE" --off-track',
+    "                                         writes: opens if the project turns Off track",
+    "",
+    "  Until it opens, the crew sees only that a note is there and who left it.",
+    "  DATE: YYYY-MM-DD, tomorrow, or +N for N days from today.",
+  ],
   handover: [
     "  harbor handover PERSON                 reads what would move, and to whom:",
     "                                         their open tasks, sign-offs, risks",
@@ -411,6 +440,33 @@ const DETAIL = {
     "",
     '  PERSON is a name, an id, or "me".',
   ],
+  handback: [
+    "  harbor handback PERSON                 writes, straight away: gives back",
+    "                                         what was handed over for their time",
+    "                                         away and is still with whoever took",
+    "                                         it, and stops showing them as away",
+    "",
+    "  Anything someone else has since taken, finished or closed stays where it",
+    "  is. If PERSON isn't marked away, it says so and changes nothing.",
+    "  harbor handover PERSON --until DATE is what marks someone away.",
+    "",
+    '  PERSON is a name, an id, or "me".',
+  ],
+  agent: [
+    "  harbor agent                           reads the tasks people gave the crew's",
+    "                                         agent (an AI crew member on People),",
+    "                                         in progress first, with their notes",
+    '  harbor agent report TASK "TEXT"        writes: the agent\'s note on the task,',
+    "                                         and moves it to In review for a person",
+    "                                         to check",
+    '  harbor agent report TASK "TEXT" --start',
+    "                                         writes: the note, and moves it to",
+    "                                         In progress",
+    "",
+    "  --agent NAME picks the agent when the crew has more than one. An agent",
+    "  never marks its own work Done; a person does, on the website or in the",
+    "  terminal app.",
+  ],
   voyage: [
     "  harbor voyage PROJECT                  reads a Done project's voyage log",
     '  harbor voyage PROJECT "YOUR LINE"      writes: adds or changes your line in it',
@@ -1362,6 +1418,32 @@ export async function run(argv, io = {}) {
         limitsText(r.set.project, r.limits, r.tasks, r.hiddenColumns),
       );
     }
+    case "note": {
+      const { positionals, values, harbor } = parse(spec(["off-track"], ["opens", "milestone"]));
+      const [project, ...words] = positionals;
+      if (!project)
+        throw new HarborError(
+          'Give a project, then the note: harbor note "NAME" "NOTE" --opens +30.',
+        );
+      const note = words.join(" ").trim();
+      if (!note) {
+        if (values.opens || values.milestone || values["off-track"])
+          throw new HarborError("Write the note too, in quotes after the project.");
+        return call("get_project", { harbor, project }, (r) => notesText(r.name, r.notesForLater));
+      }
+      return call(
+        "leave_note",
+        {
+          harbor,
+          project,
+          note,
+          ...(values.opens ? { opensOn: dueDate(values.opens) } : {}),
+          ...(values.milestone ? { milestone: values.milestone } : {}),
+          ...(values["off-track"] ? { ifOffTrack: true } : {}),
+        },
+        (r) => `Sealed your note on ${r.sealed.project}. It ${r.sealed.opens}.`,
+      );
+    }
     case "voyage": {
       const { positionals, harbor } = parse(spec());
       const [project, ...words] = positionals;
@@ -1412,6 +1494,25 @@ export async function run(argv, io = {}) {
         },
       );
     }
+    case "agent": {
+      const { positionals, values, harbor } = parse(spec(["start"], ["agent"]));
+      if (positionals[0] !== "report") {
+        none(positionals);
+        return call("agent_work", { harbor, agent: values.agent }, agentWorkText);
+      }
+      const [, task, ...words] = positionals;
+      const note = words.join(" ").trim();
+      if (!task || !note)
+        throw new HarborError(
+          'Give the task and what the agent did: harbor agent report RR-4 "Drafted it".',
+        );
+      return call(
+        "agent_update",
+        { harbor, task, note, status: values.start ? "doing" : "review", agent: values.agent },
+        (r) =>
+          `${r.updated.key ?? r.updated.title} is ${r.updated.status === "review" ? "in review for a person to check" : "in progress"}, with ${r.commentedAs}'s note.`,
+      );
+    }
     case "handback": {
       const { positionals, harbor } = parse(spec());
       const person = positionals.join(" ").trim();

package/lib/format.mjs

@@ -370,6 +370,35 @@ export function hillList(r) {
   return blocks.join("\n\n");
 }
 
+/** A project's notes for later, as get_project lists them. */
+export function notesText(project, notes) {
+  if (!notes?.length)
+    return `No notes for later on ${project}. Leave one: harbor note "${project}" "NOTE" --opens +30`;
+  const open = notes.filter((n) => n.open);
+  const sealed = notes.filter((n) => !n.open);
+  const lines = [`Notes for later · ${project}`];
+  for (const n of open) {
+    const when = n.openedOn ? `Opened ${n.openedOn}` : "Opened";
+    lines.push("", `  ${when} · left by ${n.yours ? "you" : (n.from ?? "someone")} on ${n.left}`);
+    lines.push(
+      ...String(n.note ?? "")
+        .split("\n")
+        .map((l) => `  ${l}`),
+    );
+  }
+  if (sealed.length) lines.push("");
+  for (const n of sealed) {
+    lines.push(`  Sealed · ${n.yours ? "yours" : `from ${n.from ?? "someone"}`} · ${n.opens}`);
+    if (n.yours && n.note)
+      lines.push(
+        ...String(n.note)
+          .split("\n")
+          .map((l) => `    ${l}`),
+      );
+  }
+  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 ?? [];
@@ -383,9 +412,19 @@ export function handoverText(r, { confirmHint = true } = {}) {
       group = i.group;
       lines.push("", `${group}:`);
     }
+    const due = i.due && i.kind !== "project" && i.kind !== "program" ? ` (${i.due})` : "";
+    lines.push(`  ${i.what}${due}${i.to ? `  → ${i.to}` : ""}`);
+  }
+  if (r.nobodyToTake) {
     lines.push(
-      `  ${i.what}${i.due && i.kind !== "project" && i.kind !== "program" ? ` (${i.due})` : ""}  → ${i.to ?? "nobody yet"}`,
+      "",
+      `${r.nobodyToTake} Invite someone with harbor invite EMAIL, then run this again.`,
     );
+    if (confirmHint)
+      lines.push(
+        `Until then, --confirm moves nothing; with --until DATE it only marks ${r.person} as away.`,
+      );
+    return lines.join("\n");
   }
   const room = (r.takers ?? []).filter((t) => t.note).map((t) => `${t.who} ${t.note}`);
   if (room.length) lines.push("", `This week: ${room.join(", ")}.`);
@@ -396,3 +435,32 @@ export function handoverText(r, { confirmHint = true } = {}) {
     );
   return lines.join("\n");
 }
+
+/** agent_work: the agent's tasks in the order to do them, then what waits on a person. */
+export function agentWorkText(r) {
+  if (!r.agent) return r.note;
+  const lines = [`Work for ${r.agent}${r.addedBy ? ` (added by ${r.addedBy})` : ""}`];
+  if (!r.tasks?.length) lines.push("", "Nothing to do: no open tasks are assigned to it.");
+  for (const t of r.tasks ?? []) {
+    const bits = [t.status === "doing" ? "in progress" : t.status, t.priority];
+    if (t.due) bits.push(`due ${t.due}`);
+    lines.push(
+      "",
+      `${t.key ?? t.id}  ${t.title}  (${bits.join(", ")}${t.project ? `, ${t.project}` : ""})`,
+    );
+    if (t.notes) lines.push(...t.notes.split("\n").map((l) => `    ${l}`));
+    for (const c of t.checklist ?? []) lines.push(`    [${c.done ? "x" : " "}] ${c.step}`);
+    for (const c of t.comments ?? []) lines.push(`    ${c.author ?? "Someone"}: ${c.body}`);
+  }
+  if (r.total > (r.tasks ?? []).length) lines.push("", `…and ${r.total - r.tasks.length} more.`);
+  if (r.forReview?.length)
+    lines.push(
+      "",
+      `Waiting for a person to check: ${r.forReview.map((t) => t.key ?? t.title).join(", ")}.`,
+    );
+  lines.push(
+    "",
+    'When a task is done, harbor agent report TASK "WHAT YOU DID" moves it to In review for a person to check.',
+  );
+  return lines.join("\n");
+}

package/package.json

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