@patimweb/pi-teams 1.1.0 → 1.3.0

package/src/tools/teams-watch.ts

@@ -0,0 +1,229 @@
+/**
+ * teams_watch — switch listen mode on and off, and report what it is doing.
+ *
+ * The actual polling lives in the extension, because only it can inject a
+ * message into the session and update the status line. This tool owns the
+ * configuration and the explanation; the extension restarts the loop when the
+ * config changes.
+ */
+
+import { Type } from "typebox";
+import {
+	getConfigPath,
+	resolveConnection,
+	setWatchConfig,
+	type WatchConfig,
+} from "../config/index.ts";
+import { getActiveWatchLoop, type WatchRuntimeStatus } from "../watch/loop.ts";
+import { errorResult, run, textResult, type ToolContext, type ToolResult } from "./shared.ts";
+
+interface WatchParams {
+	action?: string;
+	account?: string;
+	tenant?: string;
+	intervalSeconds?: number;
+	chats?: string[];
+	from?: string[];
+	mentionOnly?: boolean;
+	cooldownSeconds?: number;
+	maxTriggersPerHour?: number;
+}
+
+/** Renders the effective settings the same way the config file would. */
+function describe(watch: {
+	enabled: boolean;
+	intervalSeconds: number;
+	chats: string[];
+	from: string[];
+	mentionOnly: boolean;
+	cooldownSeconds: number;
+	maxTriggersPerHour: number;
+}): string {
+	return [
+		`- enabled: ${watch.enabled}`,
+		`- poll every: ${watch.intervalSeconds} s`,
+		`- chats: ${watch.chats.length > 0 ? watch.chats.map((c) => `\`${c}\``).join(", ") : "every chat with recent activity"}`,
+		`- people: ${watch.from.length > 0 ? watch.from.map((p) => `\`${p}\``).join(", ") : "any sender"}`,
+		`- mentions only: ${watch.mentionOnly}`,
+		`- cooldown per chat: ${watch.cooldownSeconds} s`,
+		`- wake limit: ${watch.maxTriggersPerHour} per hour`,
+	].join("\n");
+}
+
+/**
+ * The live facts about a running watcher, for the status action.
+ *
+ * Distinguishes "configured on" from "actually polling": after an edit to the
+ * config file the two can differ until the extension picks it up.
+ */
+function runtimeLines(runtime: WatchRuntimeStatus | undefined): string[] {
+	if (!runtime) {
+		return [
+			"Nothing is polling in this session.",
+			"",
+			"Listen mode is read when a pi session starts. If the config says `enabled: true` and this "
+				+ "says otherwise, start a new session — or switch it with the `/teams-listen` command.",
+		];
+	}
+
+	const lines = [
+		"### Running in this session",
+		"",
+		`- running: ${runtime.running}`,
+		`- chats tracked: ${runtime.trackedChats}`,
+		`- woken this hour: ${runtime.wakesThisHour}`,
+	];
+	if (runtime.lastTickAt) {
+		lines.push(`- last poll: ${new Date(runtime.lastTickAt).toLocaleTimeString()}`);
+	}
+	if (runtime.lastWakeChat) {
+		lines.push(`- last wake: ${runtime.lastWakeChat}`);
+	}
+	if (runtime.lastError) {
+		lines.push(`- ⚠️ last error: ${runtime.lastError}`);
+	}
+	return lines;
+}
+
+export const teamsWatchTool = {
+	name: "teams_watch",
+	description:
+		"Control listen mode: pi polls your Teams chats and turns an incoming message into a prompt it answers. " +
+		"Use action 'status' to see the current settings, 'enable' or 'disable' to switch it, and the optional " +
+		"fields to narrow what may wake pi (chat patterns, mentions only, interval, cooldown, hourly limit). " +
+		"The watcher runs in the extension session; this tool changes the configuration it reads.",
+	parameters: Type.Object({
+		action: Type.Optional(
+			Type.String({ description: "'status' (default), 'enable' or 'disable'" }),
+		),
+		account: Type.Optional(
+			Type.String({ description: "Account the settings apply to; omit to set them globally" }),
+		),
+		tenant: Type.Optional(
+			Type.String({
+				description:
+					"Tenant beneath that account. Used by action 'status' to report the settings in force for it — listen mode itself is configured per account, not per tenant.",
+			}),
+		),
+		intervalSeconds: Type.Optional(
+			Type.Number({ description: "Seconds between polls (minimum 15, default 60)" }),
+		),
+		chats: Type.Optional(
+			Type.Array(Type.String(), {
+				description:
+					"Glob patterns for the chats to watch — matched against topic, label, chat ID and participant names",
+			}),
+		),
+		from: Type.Optional(
+			Type.Array(Type.String(), {
+				description:
+					"Glob patterns for the people pi listens to — matched against display name, UPN and e-mail. Omit for any sender.",
+			}),
+		),
+		mentionOnly: Type.Optional(
+			Type.Boolean({ description: "Only wake pi where the signed-in user is mentioned" }),
+		),
+		cooldownSeconds: Type.Optional(
+			Type.Number({ description: "Seconds to stay quiet in a chat after waking pi for it (default 300)" }),
+		),
+		maxTriggersPerHour: Type.Optional(
+			Type.Number({ description: "Hard cap on wakes per hour (default 10)" }),
+		),
+	}),
+	promptSnippet: "Turn Teams listen mode on or off",
+	promptGuidelines: [
+		"Use teams_watch when the user wants pi to notice incoming Teams messages on its own.",
+		"Tell the user plainly that listen mode spends a model turn per incoming message, and that pi answers in their name.",
+		"Enabling listen mode takes effect immediately; the settings survive a restart.",
+	],
+
+	async execute(
+		_toolCallId: string,
+		params: WatchParams,
+		_signal: AbortSignal | undefined,
+		_onUpdate: undefined,
+		_ctx: ToolContext,
+	): Promise<ToolResult> {
+		return run(async () => {
+			const action = (params.action ?? "status").toLowerCase();
+
+			// Reported from the resolved connection, so the answer shows what is in
+			// force for that account and tenant — not just what the file says.
+			const inspect = () => {
+				try {
+					return resolveConnection(params.account, params.tenant).watch;
+				} catch {
+					return undefined;
+				}
+			};
+
+			const patch: WatchConfig = {};
+			if (params.intervalSeconds !== undefined) patch.intervalSeconds = params.intervalSeconds;
+			if (params.chats !== undefined) patch.chats = params.chats;
+		if (params.from !== undefined) patch.from = params.from;
+			if (params.mentionOnly !== undefined) patch.mentionOnly = params.mentionOnly;
+			if (params.cooldownSeconds !== undefined) patch.cooldownSeconds = params.cooldownSeconds;
+			if (params.maxTriggersPerHour !== undefined) {
+				patch.maxTriggersPerHour = params.maxTriggersPerHour;
+			}
+
+			switch (action) {
+				case "status": {
+					const watch = inspect();
+					if (!watch) {
+						return errorResult(
+							`No usable Teams account for these settings. Check ${getConfigPath()}.`,
+						);
+					}
+					const loop = getActiveWatchLoop();
+					const runtime = loop?.status();
+					return textResult(
+						[
+							`## Listen mode — ${watch.enabled ? "on" : "off"}`,
+							"",
+							describe(watch),
+							"",
+							...runtimeLines(runtime),
+						].join("\n"),
+						{ watch, runtime },
+					);
+				}
+
+				case "enable": {
+					const watch = setWatchConfig({ ...patch, enabled: true }, params.account);
+					return textResult(
+						[
+							"## Listen mode — on",
+							"",
+							describe(watch),
+							"",
+							"pi now polls these chats and treats a new message as a prompt. It answers in your name " +
+								"and under the safety level in force, so anything it decides to send still follows the " +
+								"usual confirmation rules.",
+							"",
+							`Written to ${getConfigPath()}.`,
+						].join("\n"),
+						{ watch },
+					);
+				}
+
+				case "disable": {
+					const watch = setWatchConfig({ ...patch, enabled: false }, params.account);
+					return textResult(
+						[
+							"## Listen mode — off",
+							"",
+							describe(watch),
+							"",
+							"Polling stops now; the settings stay in the file for the next time.",
+						].join("\n"),
+						{ watch },
+					);
+				}
+
+				default:
+					return errorResult(`Unknown action "${action}". Use 'status', 'enable' or 'disable'.`);
+			}
+		});
+	},
+};

package/src/tools/tool-names.ts

@@ -15,16 +15,19 @@ export const MUTATION_TOOLS = new Set<string>([
 	"teams_create_chat",
 	"teams_delete_message",
 	"teams_react",
-	// Structure
-	"teams_create_channel",
+	"teams_mark_read",
+	"teams_update_message",
+	"teams_chat_members",
 	// Presence
 	"teams_set_presence",
 	"teams_set_status_message",
 	// Calendar
 	"teams_create_meeting",
 	"teams_update_meeting",
+	"teams_respond_invite",
 	"teams_cancel_meeting",
 	// Local configuration and credentials
 	"teams_setup",
 	"teams_logout",
+	"teams_watch",
 ]);

package/src/types.ts

@@ -86,6 +86,17 @@ export interface ChatSummary {
 	webUrl?: string;
 }
 
+export interface ChatMemberSummary {
+	/** conversationMember id — the identifier DELETE /chats/{id}/members/{id} needs */
+	membershipId: string;
+	/** Object id of the person behind the membership */
+	userId?: string;
+	displayName: string;
+	upn?: string;
+	mail?: string;
+	roles: string[];
+}
+
 // ---------------------------------------------------------------------------
 // Messages
 // ---------------------------------------------------------------------------

package/src/utils/errors.ts

@@ -40,6 +40,7 @@ const CONSENT_HINTS: Record<string, string> = {
 	"ChannelMessage.Send": "posting in channels",
 	"Chat.ReadWrite": "reading and sending chat messages",
 	"ChatMessage.Send": "sending chat messages",
+	"ChatMember.ReadWrite": "removing someone from a chat",
 	"Presence.ReadWrite": "reading and setting your presence",
 	"Calendars.ReadWrite": "reading and creating calendar events",
 	"OnlineMeetings.ReadWrite": "creating Teams meetings",

package/src/utils/formatting.ts

@@ -82,18 +82,6 @@ export function htmlToText(content: string, contentType = "html"): string {
 		.trim();
 }
 
-/** Convert plain text to the minimal HTML Teams expects for a message body. */
-export function textToHtml(text: string): string {
-	const escaped = text
-		.replace(/&/g, "&")
-		.replace(/</g, "&lt;")
-		.replace(/>/g, "&gt;");
-	return escaped
-		.split(/\n{2,}/)
-		.map((para) => `<p>${para.replace(/\n/g, "<br>")}</p>`)
-		.join("");
-}
-
 // ---------------------------------------------------------------------------
 // Dates
 // ---------------------------------------------------------------------------
@@ -126,6 +114,68 @@ export function formatRelative(iso: string | undefined): string {
 	return formatDate(iso);
 }
 
+const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec",
+];
+
+/**
+ * Split a naive Graph date-time into its parts, as UTC.
+ *
+ * Availability views and free/busy blocks arrive already localised to the zone
+ * the caller asked Graph for, so re-interpreting them in the machine's zone
+ * would shift every time by the offset between the two.
+ */
+function naiveParts(value: string | undefined):
+	| { weekday: string; day: number; month: string; year: number; time: string }
+	| undefined {
+	if (!value) return undefined;
+	const match = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})/.exec(value.trim());
+	if (!match) return undefined;
+	const [, year, month, day, hour, minute] = match;
+	const asUtc = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
+	return {
+		weekday: WEEKDAYS[asUtc.getUTCDay()] ?? "",
+		day: Number(day),
+		month: MONTHS[Number(month) - 1] ?? "",
+		year: Number(year),
+		time: `${hour}:${minute}`,
+	};
+}
+
+/** "Mon 15 Sep 2026" — a window's day, without the clock time. */
+export function formatNaiveDay(value: string | undefined): string {
+	const parts = naiveParts(value);
+	if (!parts) return value ?? "";
+	return `${parts.weekday} ${parts.day} ${parts.month} ${parts.year}`;
+}
+
+/** "09:00–09:30" — the clock part of a free/busy block. */
+export function formatTimeRange(start: string | undefined, end: string | undefined): string {
+	const from = naiveParts(start);
+	const to = naiveParts(end);
+	if (!from || !to) return "unknown time";
+	return `${from.time}–${to.time}`;
+}
+
+/** "Mon 15 Sep, 09:00–09:30" — one proposed slot. */
+export function formatSlotRange(start: string | undefined, end: string | undefined): string {
+	const parts = naiveParts(start);
+	if (!parts) return `${start ?? "?"}–${end ?? "?"}`;
+	return `${parts.weekday} ${parts.day} ${parts.month}, ${formatTimeRange(start, end)}`;
+}
+
 /** Shorten a string for previews, without cutting mid-escape. */
 export function truncate(text: string, max: number): string {
 	const oneLine = text.replace(/\s*\n\s*/g, " ").trim();

package/src/utils/richtext.ts

@@ -0,0 +1,150 @@
+/**
+ * Markdown-ish text → the HTML subset Microsoft Teams renders in a message.
+ *
+ * Why this exists: a message body is HTML, but the model writes markdown. Sent
+ * raw, `**wichtig**` arrives as literal asterisks and `- Punkt` as literal
+ * dashes — which is exactly the "wall of text" a person sees in a chat when
+ * nothing was formatted for the medium.
+ *
+ * Teams supports far less HTML than a browser. This translates only what
+ * survives in a chat bubble:
+ *
+ *   `**bold**` → `<b>`            `- item` → `<ul><li>`
+ *   `*italic*` / `_italic_` → `<i>`   `1. item` → `<ol><li>`
+ *   `` `code` `` → `<code>`        ``` fences → `<pre>`
+ *   `~~struck~~` → `<s>`          `# Heading` → a bold line
+ *   `[label](url)` → `<a href>`
+ *
+ * Tables and images are deliberately unsupported: Teams renders neither in a
+ * chat, so pretending otherwise would produce worse output than plain text.
+ * Everything else is escaped and kept as written.
+ */
+
+const HTML_ESCAPES: Record<string, string> = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+};
+
+function escapeHtml(text: string): string {
+	return text.replace(/[&<>]/g, (char) => HTML_ESCAPES[char] ?? char);
+}
+
+/**
+ * Inline markup of a single line.
+ *
+ * Order matters: code spans are protected first (so `**` inside them stays
+ * literal), then links, then emphasis. The underscore rule requires a boundary
+ * on both sides so `snake_case_name` survives untouched.
+ */
+function inline(raw: string): string {
+	let text = escapeHtml(raw);
+
+	text = text.replace(/`([^`]+)`/g, "<code>$1</code>");
+	text = text.replace(
+		/\[([^\]]+)\]\((https?:\/\/[^\s)]+|mailto:[^\s)]+)\)/g,
+		'<a href="$2">$1</a>',
+	);
+	text = text.replace(/\*\*([^*]+)\*\*/g, "<b>$1</b>");
+	text = text.replace(/(^|[^*\w])\*([^*\n]+)\*/g, "$1<i>$2</i>");
+	text = text.replace(/(^|[\s(])_([^_\n]+)_(?=$|[\s).,;:!?])/g, "$1<i>$2</i>");
+	text = text.replace(/~~([^~]+)~~/g, "<s>$1</s>");
+
+	return text;
+}
+
+const BULLET = /^\s*[-*+]\s+(.*)$/;
+const NUMBERED = /^\s*\d+[.)]\s+(.*)$/;
+const HEADING = /^\s{0,3}#{1,6}\s+(.*)$/;
+
+/**
+ * Convert a message body to Teams HTML.
+ *
+ * Blank lines separate paragraphs, single newlines become `<br>` inside one —
+ * which is what a person typing into the chat box gets, and the safest
+ * assumption for text that was generated, not composed.
+ */
+export function markdownToTeamsHtml(text: string): string {
+	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+	const blocks: string[] = [];
+
+	let paragraph: string[] = [];
+	let list: { ordered: boolean; items: string[] } | undefined;
+	let code: string[] | undefined;
+
+	const flushParagraph = () => {
+		if (paragraph.length === 0) return;
+		blocks.push(`<p>${paragraph.map(inline).join("<br>")}</p>`);
+		paragraph = [];
+	};
+
+	const flushList = () => {
+		if (!list) return;
+		const tag = list.ordered ? "ol" : "ul";
+		const items = list.items.map((item) => `<li>${inline(item)}</li>`).join("");
+		blocks.push(`<${tag}>${items}</${tag}>`);
+		list = undefined;
+	};
+
+	const flushBlock = () => {
+		flushParagraph();
+		flushList();
+	};
+
+	for (const line of lines) {
+		// A fence swallows everything until the next one, verbatim.
+		if (/^\s*```/.test(line)) {
+			if (code) {
+				blocks.push(`<pre>${escapeHtml(code.join("\n"))}</pre>`);
+				code = undefined;
+			} else {
+				flushBlock();
+				code = [];
+			}
+			continue;
+		}
+		if (code) {
+			code.push(line);
+			continue;
+		}
+
+		if (line.trim() === "") {
+			flushBlock();
+			continue;
+		}
+
+		const heading = HEADING.exec(line);
+		if (heading) {
+			flushBlock();
+			blocks.push(`<p><b>${inline(heading[1])}</b></p>`);
+			continue;
+		}
+
+		const bullet = BULLET.exec(line);
+		if (bullet) {
+			flushParagraph();
+			if (list && list.ordered) flushList();
+			list ??= { ordered: false, items: [] };
+			list.items.push(bullet[1]);
+			continue;
+		}
+
+		const numbered = NUMBERED.exec(line);
+		if (numbered) {
+			flushParagraph();
+			if (list && !list.ordered) flushList();
+			list ??= { ordered: true, items: [] };
+			list.items.push(numbered[1]);
+			continue;
+		}
+
+		flushList();
+		paragraph.push(line);
+	}
+
+	// An unterminated fence is still code, not lost text.
+	if (code) blocks.push(`<pre>${escapeHtml(code.join("\n"))}</pre>`);
+	flushBlock();
+
+	return blocks.join("");
+}

package/src/utils/slots.ts

@@ -0,0 +1,171 @@
+/**
+ * Finding a slot everyone is free in.
+ *
+ * Graph returns availability as a *string*, one character per time slot since
+ * the window start — so the one thing that can go silently wrong is the mapping
+ * from character index back to a clock time. That mapping lives here, pure and
+ * testable, instead of inside a tool where the only test would be a live
+ * calendar.
+ *
+ * Naive date-times ("2026-09-15T09:00:00", no offset) are parsed as UTC on
+ * purpose: they already carry the zone the caller asked Graph for, and reading
+ * them as UTC keeps the arithmetic independent of the machine's own zone.
+ */
+
+/** One person's availability, as Graph's availability view expresses it. */
+export interface BusyView {
+	/** Name to report the person by */
+	name: string;
+	/** One character per slot: `0` free, `1` tentative, `2` busy, `3` out of office, `4` working elsewhere */
+	view: string;
+}
+
+export interface SlotWindow {
+	/** First slot, naive ISO, aligned with index 0 of every view */
+	start: string;
+	/** Slot width in minutes — the same value the Graph call used */
+	intervalMinutes: number;
+	/** Ignore slots that begin before this naive ISO (used to skip the past) */
+	notBefore?: string;
+	/** Also ignore slots outside Mon–Fri, 09:00–17:00 */
+	workingHoursOnly?: boolean;
+}
+
+export interface FreeSlot {
+	start: string;
+	end: string;
+}
+
+const FREE = "0";
+const WORKDAY_START = 9 * 60;
+const WORKDAY_END = 17 * 60;
+const MINUTE_MS = 60_000;
+
+/**
+ * Parse a naive Graph date-time into a UTC timestamp.
+ *
+ * Returns undefined for anything without a date and time rather than guessing:
+ * a missing value must not become "1 January 1970, which looks free".
+ */
+export function parseNaive(value: string | undefined): number | undefined {
+	if (!value) return undefined;
+	const match = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?/.exec(value.trim());
+	if (!match) return undefined;
+	const [, year, month, day, hour, minute, second] = match;
+	return Date.UTC(
+		Number(year),
+		Number(month) - 1,
+		Number(day),
+		Number(hour),
+		Number(minute),
+		Number(second ?? 0),
+	);
+}
+
+/** UTC timestamp → naive ISO without milliseconds. */
+export function formatNaive(timestamp: number): string {
+	return new Date(timestamp).toISOString().slice(0, 19);
+}
+
+/** Shift a naive date-time by whole minutes. */
+export function addMinutes(naive: string, minutes: number): string | undefined {
+	const parsed = parseNaive(naive);
+	return parsed === undefined ? undefined : formatNaive(parsed + minutes * MINUTE_MS);
+}
+
+/** `YYYY-MM-DDT00:00:00` for today + offset, in the machine's time zone. */
+export function localDayStart(offsetDays = 0): string {
+	const date = new Date();
+	date.setDate(date.getDate() + offsetDays);
+	return `${localDate(date)}T00:00:00`;
+}
+
+/** The current time as a naive date-time, in the machine's time zone. */
+export function localNow(): string {
+	return `${localDate(new Date())}T${localTime(new Date())}`;
+}
+
+/** The machine's time zone, for calls that would otherwise default to UTC. */
+export function localTimeZone(): string {
+	try {
+		return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+	} catch {
+		return "UTC";
+	}
+}
+
+function localDate(date: Date): string {
+	const pad = (n: number) => String(n).padStart(2, "0");
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+function localTime(date: Date): string {
+	const pad = (n: number) => String(n).padStart(2, "0");
+	return `${pad(date.getHours())}:${pad(date.getMinutes())}:00`;
+}
+
+function insideWorkingHours(start: number, end: number): boolean {
+	const from = new Date(start);
+	const to = new Date(end);
+	const weekday = from.getUTCDay();
+	if (weekday === 0 || weekday === 6) return false;
+	// A slot has to fit inside one working day; a window across midnight is not
+	// a 30-minute meeting anyway.
+	if (from.toISOString().slice(0, 10) !== to.toISOString().slice(0, 10)) return false;
+	const startMinutes = from.getUTCHours() * 60 + from.getUTCMinutes();
+	const endMinutes = to.getUTCHours() * 60 + to.getUTCMinutes();
+	return startMinutes >= WORKDAY_START && endMinutes <= WORKDAY_END;
+}
+
+/** The first slots in which nobody has anything. */
+export function findCommonFreeSlots(
+	views: readonly BusyView[],
+	window: SlotWindow,
+	limit = 5,
+): FreeSlot[] {
+	const base = parseNaive(window.start);
+	if (base === undefined || views.length === 0) return [];
+
+	// The shortest view decides how far the search goes: where Graph truncated
+	// a person's availability the tail is unknown, and unknown is not free.
+	const horizon = Math.min(...views.map((entry) => entry.view.length));
+	const earliest = parseNaive(window.notBefore);
+	const step = window.intervalMinutes * MINUTE_MS;
+
+	const slots: FreeSlot[] = [];
+	for (let index = 0; index < horizon && slots.length < limit; index += 1) {
+		if (views.some((entry) => entry.view[index] !== FREE)) continue;
+
+		const start = base + index * step;
+		const end = start + step;
+		if (earliest !== undefined && start < earliest) continue;
+		if (window.workingHoursOnly && !insideWorkingHours(start, end)) continue;
+
+		slots.push({ start: formatNaive(start), end: formatNaive(end) });
+	}
+
+	return slots;
+}
+
+/**
+ * The statuses keeping everyone apart, for when no slot is free.
+ *
+ * Turns "nothing works" into something a person can act on, and reports only
+ * times and statuses — never what the appointment is.
+ */
+export function describeBusy(
+	busy: readonly {
+		scheduleId: string;
+		busy: Array<{ status: string; start: string; end: string }>;
+	}[],
+	names: Map<string, string>,
+): string[] {
+	return busy.map((entry) => {
+		const name = names.get(entry.scheduleId.toLowerCase()) ?? entry.scheduleId;
+		const blocks = entry.busy
+			.slice(0, 6)
+			.map((block) => `${block.start.slice(11, 16)}–${block.end.slice(11, 16)} (${block.status})`)
+			.join(", ");
+		return `- ${name}: ${blocks || "no busy blocks reported"}`;
+	});
+}