pi-roundtable-web 0.27.1 → 0.29.0

package/src/app/room-log.ts

@@ -1,10 +1,12 @@
 import type { SQL } from "bun";
 import type { Migration } from "pi-roundtable";
-import type {
-	HostAuthorKind,
-	PictureRef,
-	RoomFile,
-	RoomMessage,
+import {
+	type HostAuthorKind,
+	type PictureRef,
+	type RoomFile,
+	type RoomIntercom,
+	type RoomMessage,
+	START_OVER_TEXT,
 } from "../api-types.ts";
 import { storedJson } from "../host/stored-json.ts";
 
@@ -27,6 +29,8 @@ export interface NewRoomMessage {
 	at?: Date;
 	/** An internal note: shown to the room's readers, never handed to the agent. */
 	note?: true;
+	/** A message between agents, drawn as a small card. */
+	intercom?: RoomIntercom;
 }
 
 interface Row {
@@ -44,6 +48,7 @@ interface Row {
 	picture: PictureRef | string | null;
 	edited_at: Date | null;
 	note: boolean | null;
+	intercom?: RoomIntercom | string | null;
 }
 
 /** The most messages one page of history holds. */
@@ -70,6 +75,9 @@ function messageOf(row: Row): RoomMessage {
 				}),
 		...(row.edited_at === null ? {} : { edited: true as const }),
 		...(row.note ? { note: true as const } : {}),
+		...(row.intercom == null
+			? {}
+			: { intercom: storedJson(row.intercom, "intercom card") }),
 	};
 }
 
@@ -128,6 +136,22 @@ export class RoomLog {
 		},
 	};
 
+	/** The column that marks a message between agents, with which way it went and the other agent. */
+	static readonly intercomMigration: Migration = {
+		name: "web-room-messages-intercom",
+		up: async (sql) => {
+			await sql`ALTER TABLE web_room_messages ADD COLUMN IF NOT EXISTS intercom jsonb`;
+		},
+	};
+
+	/** Finds a room's start-over lines without reading the whole room. */
+	static readonly startOverMigration: Migration = {
+		name: "web-room-messages-start-over",
+		up: async (sql) => {
+			await sql`CREATE INDEX IF NOT EXISTS web_room_messages_start_over ON web_room_messages (room, id) WHERE kind = 'system' AND text = 'Conversation started over'`;
+		},
+	};
+
 	async append(message: NewRoomMessage): Promise<RoomMessage> {
 		const [row] = await this.#insert(message, false);
 		if (!row) throw new Error("the room log stored nothing");
@@ -153,24 +177,25 @@ export class RoomLog {
 	async #insert(message: NewRoomMessage, once: boolean): Promise<Row[]> {
 		const files = JSON.stringify(message.files ?? []);
 		const picture = message.picture ? JSON.stringify(message.picture) : null;
+		const intercom = message.intercom ? JSON.stringify(message.intercom) : null;
 		const at = message.at ?? new Date();
 		return once
 			? await this.#sql`
 				INSERT INTO web_room_messages (room, kind, principal_id, agent, author_name, text, files,
-					author_kind, author_label, picture, reference, created_at, note)
+					author_kind, author_label, picture, reference, created_at, note, intercom)
 				VALUES (${message.room}, ${message.kind}, ${message.principalId ?? null},
 					${message.agent ?? null}, ${message.author}, ${message.text}, ${files}::jsonb,
 					${message.authorKind ?? null}, ${message.authorLabel ?? null}, ${picture}::jsonb,
-					${message.reference ?? null}, ${at}, ${message.note === true})
+					${message.reference ?? null}, ${at}, ${message.note === true}, ${intercom}::jsonb)
 				ON CONFLICT (room, reference) WHERE reference IS NOT NULL DO NOTHING
 				RETURNING *`
 			: await this.#sql`
 				INSERT INTO web_room_messages (room, kind, principal_id, agent, author_name, text, files,
-					author_kind, author_label, picture, reference, created_at, note)
+					author_kind, author_label, picture, reference, created_at, note, intercom)
 				VALUES (${message.room}, ${message.kind}, ${message.principalId ?? null},
 					${message.agent ?? null}, ${message.author}, ${message.text}, ${files}::jsonb,
 					${message.authorKind ?? null}, ${message.authorLabel ?? null}, ${picture}::jsonb,
-					${message.reference ?? null}, ${at}, ${message.note === true})
+					${message.reference ?? null}, ${at}, ${message.note === true}, ${intercom}::jsonb)
 				RETURNING *`;
 	}
 
@@ -241,27 +266,50 @@ export class RoomLog {
 		return found;
 	}
 
-	/** The newest `limit` messages older than `before` (all of them when absent), oldest first. */
+	/**
+	 * The newest `limit` messages older than `before` (all of them when absent), oldest first, of
+	 * the room's conversation: from its latest start-over line, which the page includes, on. With
+	 * `until`, the id of one of its start-over lines, those of the conversation that line ended
+	 * instead: older than the line, back to the start-over line before it.
+	 */
 	async page(
 		room: string,
 		before: number | undefined,
 		limit: number,
+		until?: number,
 	): Promise<{ messages: RoomMessage[]; more: boolean }> {
 		const count = Math.min(Math.max(Math.trunc(limit), 1), PAGE_LIMIT);
-		const rows: Row[] =
-			before === undefined
-				? await this.#sql`
-					SELECT * FROM web_room_messages WHERE room = ${room}
-					ORDER BY id DESC LIMIT ${count + 1}`
-				: await this.#sql`
-					SELECT * FROM web_room_messages WHERE room = ${room} AND id < ${before}
-					ORDER BY id DESC LIMIT ${count + 1}`;
+		const start = await this.startOver(room, until);
+		// The live conversation includes its own start line; an archived one ends before the next.
+		const above = until === undefined ? (start ?? 1) - 1 : (start ?? 0);
+		const below =
+			until === undefined
+				? before
+				: before === undefined
+					? until
+					: Math.min(before, until);
+		const rows: Row[] = await this.#sql`
+			SELECT * FROM web_room_messages
+			WHERE room = ${room} AND id > ${above}
+				AND (${below ?? null}::bigint IS NULL OR id < ${below ?? null}::bigint)
+			ORDER BY id DESC LIMIT ${count + 1}`;
 		return {
 			messages: rows.slice(0, count).map(messageOf).reverse(),
 			more: rows.length > count,
 		};
 	}
 
+	/** The id of the room's latest start-over line, or of the latest one older than `before`. */
+	async startOver(room: string, before?: number): Promise<number | undefined> {
+		const [row]: { id: string | number | bigint | null }[] = await this.#sql`
+			SELECT max(id) AS id FROM web_room_messages
+			WHERE room = ${room} AND kind = 'system' AND text = ${START_OVER_TEXT}
+				AND (${before ?? null}::bigint IS NULL OR id < ${before ?? null}::bigint)`;
+		return row?.id === null || row?.id === undefined
+			? undefined
+			: Number(row.id);
+	}
+
 	/** Deletes every message of a room that is gone for good; returns how many. */
 	async removeRoom(room: string): Promise<number> {
 		const rows: unknown[] = await this

package/src/app/rooms.ts

@@ -5,6 +5,7 @@ import type {
 	AgentTeam,
 	AvatarStudio,
 	ChannelKey,
+	ConversationMode,
 	ConversationModes,
 } from "pi-roundtable";
 import {
@@ -12,10 +13,22 @@ import {
 	channelKey,
 	characterOf,
 	groupRoomKey,
+	helperSurface,
 	isHelper,
 	roomOf,
 } from "pi-roundtable";
-import type { RoomKind, RoomView } from "../api-types.ts";
+import type { RoomKind, RoomMode, RoomView } from "../api-types.ts";
+
+/** A conversation's modes as a room shows them: an inherited one names where it comes from. */
+export function roomModeOf(mode: ConversationMode): RoomMode {
+	const from = mode.inheritedFrom;
+	return {
+		yolo: mode.yolo,
+		longRunning: mode.longRunning,
+		...(from ? { inheritedFrom: from.name ?? from.channel } : {}),
+	};
+}
+
 import type { PushMutes } from "../push/mutes.ts";
 import type { RoomLog } from "./room-log.ts";
 import type { WebThreads } from "./threads.ts";
@@ -62,6 +75,8 @@ const THREAD_ID = /^thread\.[0-9a-f-]{36}$/;
  */
 export class Rooms {
 	readonly #options: RoomsOptions;
+	/** The rooms of temp knights made on Discord that someone opened by their address here. */
+	readonly #opened = new Set<string>();
 
 	constructor(options: RoomsOptions) {
 		this.#options = options;
@@ -176,12 +191,11 @@ export class Rooms {
 		const thread = await this.#options.threads.get(room.name);
 		if (!thread) return undefined;
 		const { modes, activity, log } = this.#options;
-		const { yolo, longRunning } = modes.peek(key);
 		const last = (await log.lastOf([key])).get(key);
 		return {
 			home: false,
 			readOnly: true,
-			mode: { yolo, longRunning },
+			mode: roomModeOf(modes.peek(key)),
 			...activity(key),
 			kind: "thread",
 			name: thread.id,
@@ -193,6 +207,19 @@ export class Rooms {
 		};
 	}
 
+	/**
+	 * The view of a temp knight's room that the list leaves out, opened by its address: from then on
+	 * the list shows it. Undefined for any other room.
+	 */
+	async openHelper(key: ChannelKey): Promise<RoomView | undefined> {
+		const room = await this.resolve(key);
+		if (room?.kind !== "agent") return undefined;
+		const agent = this.#options.directory.agent(room.name);
+		if (helperSurface(agent) !== "discord") return undefined;
+		this.#opened.add(room.name);
+		return (await this.list()).find((one) => one.key === key);
+	}
+
 	async list(): Promise<RoomView[]> {
 		const { surface, directory, modes, mutes, activity, log, threads } =
 			this.#options;
@@ -207,11 +234,10 @@ export class Rooms {
 			key: ChannelKey,
 			rest: Pick<RoomView, "kind" | "name" | "displayName"> & Partial<RoomView>,
 		): RoomView => {
-			const { yolo, longRunning } = modes.peek(key);
 			return {
 				home: key === home,
 				readOnly: false,
-				mode: { yolo, longRunning },
+				mode: roomModeOf(modes.peek(key)),
 				...(muted.has(key) ? { muted: true as const } : {}),
 				...(notes && rest.kind !== "thread" ? { notes: true as const } : {}),
 				...activity(key),
@@ -264,9 +290,21 @@ export class Rooms {
 		// Home first; the others keep the team's order.
 		rooms.sort((a, b) => Number(b.home) - Number(a.home));
 		const last = await log.lastOf(rooms.map((room) => room.key));
-		return rooms.map((room) => {
+		// A temp knight made on Discord works there: its room here shows once it has a message or
+		// someone opened it by its address.
+		const quiet = new Set<string>(
+			agents
+				.filter(
+					(agent) =>
+						helperSurface(agent) === "discord" && !this.#opened.has(agent.name),
+				)
+				.map((agent) => agentRoomKey(surface, agent.name))
+				.filter((key) => !last.has(key)),
+		);
+		return rooms.flatMap((room) => {
+			if (quiet.has(room.key)) return [];
 			const message = last.get(room.key);
-			return message ? { ...room, last: message } : room;
+			return [message ? { ...room, last: message } : room];
 		});
 	}
 }

package/src/app/routes.ts

@@ -2,6 +2,7 @@ import type {
 	AgentDirectory,
 	AgentTeam,
 	AvatarStudio,
+	ChannelKey,
 	ConversationModes,
 	ConversationPort,
 	IdentityService,
@@ -37,6 +38,7 @@ import type {
 	WorkspaceRootsView,
 	WorkspaceSave,
 } from "../api-types.ts";
+import { isStartOver } from "../api-types.ts";
 import type { Authenticated } from "../auth/authenticator.ts";
 import { type ConsolePresentation, message } from "../features.ts";
 import type { Gate } from "../gate.ts";
@@ -56,8 +58,9 @@ import type { LayoutStore } from "./layout.ts";
 import { LayoutRoutes } from "./layout-routes.ts";
 import { PromptApi, type PromptApiOptions } from "./prompt-routes.ts";
 import { PAGE_LIMIT, type RoomLog } from "./room-log.ts";
-import type { ResolvedRoom, Rooms } from "./rooms.ts";
+import { type ResolvedRoom, type Rooms, roomModeOf } from "./rooms.ts";
 import { SkillDocApi } from "./skill-doc-routes.ts";
+import { SkillGroupApi } from "./skill-group-routes.ts";
 import type { AppSurface } from "./surface.ts";
 import { TeamApi } from "./team-routes.ts";
 import type { WebThreads } from "./threads.ts";
@@ -79,12 +82,12 @@ export interface AppApiOptions {
 	presentation?: ConsolePresentation;
 	surface: AppSurface;
 	rooms: Rooms;
-	log: Pick<RoomLog, "page" | "lastOf" | "removeRoom">;
+	log: Pick<RoomLog, "page" | "lastOf" | "removeRoom" | "get" | "startOver">;
 	cards: Pick<CardLog, "during" | "removeRoom">;
 	uploads: Uploads;
 	/** Where stored files are read from. */
 	files: FileDir;
-	modes: Pick<ConversationModes, "set" | "peek">;
+	modes: Pick<ConversationModes, "set" | "peek" | "forget">;
 	/** The rooms whose push the owners muted. */
 	mutes: Pick<PushMutes, "set" | "setMany">;
 	/** The dispatch threads, which go with the room they hang under. */
@@ -131,11 +134,17 @@ export interface AppApiOptions {
 			add: readonly string[],
 			remove: readonly string[],
 		): Promise<string[]>;
-		/** The registry's documents: a skill's SKILL.md read, saved and made, and its versions. */
+		/** The registry's documents: a skill's SKILL.md read, saved, made and deleted, and its versions. */
 		documents: Pick<
 			SkillRegistry,
-			"document" | "saveDocument" | "createDocument" | "documentHistory"
+			| "document"
+			| "saveDocument"
+			| "createDocument"
+			| "documentHistory"
+			| "delete"
 		>;
+		/** The registry's skill groups: listed, saved and deleted. */
+		groups: Pick<SkillRegistry, "groups" | "setGroup" | "deleteGroup">;
 	};
 	/** Present when the host has prompt documents (the prompts plugin): the main prompts the owner edits. */
 	prompts?: PromptApiOptions["prompts"];
@@ -279,6 +288,7 @@ export class AppApi {
 	readonly #helpers: HelperRoutes;
 	readonly #prompts: PromptApi | undefined;
 	readonly #skillDocs: SkillDocApi | undefined;
+	readonly #skillGroups: SkillGroupApi | undefined;
 
 	constructor(options: AppApiOptions) {
 		this.#options = options;
@@ -305,6 +315,17 @@ export class AppApi {
 					catalog: () => options.skills?.catalog() ?? [],
 				})
 			: undefined;
+		const skills = options.skills;
+		this.#skillGroups = skills
+			? new SkillGroupApi({
+					groups: skills.groups,
+					catalog: () => skills.catalog(),
+					attach: (agent, add, remove) => skills.attach(agent, add, remove),
+					active: (agent) =>
+						options.directory.agent(agent)?.status === "active",
+					changed: () => options.changed(),
+				})
+			: undefined;
 		this.#team = new TeamApi({
 			surface: options.surface.surface,
 			rooms: options.rooms,
@@ -388,6 +409,7 @@ export class AppApi {
 					"workspace",
 					"prompts",
 					"skill-docs",
+					"skill-groups",
 				].includes(second ?? ""));
 		if (!mine) return undefined;
 		try {
@@ -486,6 +508,11 @@ export class AppApi {
 				throw new HttpError(404, "This host has no skills.");
 			return this.#skillDocs.handle(request, parts, owner);
 		}
+		if (area === "skill-groups") {
+			if (!this.#skillGroups)
+				throw new HttpError(404, "This host has no skills.");
+			return this.#skillGroups.handle(request, parts, owner);
+		}
 		throw new HttpError(404, "There is no such API.");
 	}
 
@@ -559,8 +586,11 @@ export class AppApi {
 		const room = await rooms.resolve(key);
 		if (!room) throw notFound();
 		if (!action && method === "GET") {
-			// A thread dismissed from the list still opens by its address; the page asks for its view.
-			const view = await rooms.threadView(room.key);
+			// A thread dismissed from the list, or a temp knight's room the list leaves out, still opens
+			// by its address; the page asks for its view.
+			const view =
+				(await rooms.threadView(room.key)) ??
+				(await rooms.openHelper(room.key));
 			if (!view) throw notFound();
 			return json({ room: view } satisfies RoomOneView);
 		}
@@ -580,17 +610,23 @@ export class AppApi {
 			const params = new URL(request.url).searchParams;
 			const before = params.get("before");
 			const limit = params.get("limit");
+			const archive = params.get("archive");
 			const beforeId = before === null ? undefined : Number(before);
+			const archiveId = archive === null ? undefined : Number(archive);
 			const count = limit === null ? PAGE_LIMIT : Number(limit);
 			if (
 				(beforeId !== undefined && !Number.isInteger(beforeId)) ||
+				(archiveId !== undefined && !Number.isInteger(archiveId)) ||
 				!Number.isInteger(count) ||
 				count < 1
 			)
-				throw bad("before and limit must be whole numbers.");
+				throw bad("before, limit and archive must be whole numbers.");
+			if (archiveId !== undefined)
+				return json(await this.#archived(room.key, archiveId, beforeId, count));
 			const page = await log.page(room.key, beforeId, count);
 			// The cards stand among the messages by the time they opened; a page that has older
-			// messages leaves the cards before its first one to the older page.
+			// messages leaves the cards before its first one to the older page, and a conversation
+			// started over leaves the archived one's cards to it.
 			const first = page.messages[0];
 			const { reads, nameOf } = this.#options;
 			const self = admission.visitor.principal.id;
@@ -599,7 +635,9 @@ export class AppApi {
 				...page,
 				messages: withExpiredFiles(page.messages, this.#options.files),
 				cards: await cards.during(room.key, {
-					...(page.more && first ? { from: first.at } : {}),
+					...(first && (page.more || isStartOver(first))
+						? { from: first.at }
+						: {}),
 					...(beforeId === undefined ? {} : { before: beforeId }),
 				}),
 				...(reads && nameOf
@@ -624,13 +662,19 @@ export class AppApi {
 			}
 			if (Object.keys(change).length === 0)
 				throw bad("Give yolo or longRunning.");
+			if (modes.peek(room.key).inheritedFrom)
+				throw bad(
+					"This room follows the modes of the conversation that made it; switch them there.",
+				);
 			const mode = await modes.set(room.key, change, owner);
-			return json({ mode: { yolo: mode.yolo, longRunning: mode.longRunning } });
+			return json({ mode: roomModeOf(mode) });
 		}
 		if (action === "start-over" && method === "POST" && parts.length === 4) {
 			if (room.readOnly) throw notFound();
 			await this.#owner(admission);
 			await conversations.startFresh(room.key);
+			// The other pages read the room list again: its unread count and last line changed.
+			this.#options.changed();
 			return json({ ok: true });
 		}
 		if (
@@ -653,6 +697,37 @@ export class AppApi {
 		throw new HttpError(404, "There is no such API.");
 	}
 
+	/**
+	 * A page of the conversation a start-over line of the room ended, read only: its messages and
+	 * the cards that opened within it. A line that is not one of the room's start-overs names none.
+	 */
+	async #archived(
+		room: ChannelKey,
+		until: number,
+		before: number | undefined,
+		count: number,
+	): Promise<MessagesView> {
+		const { log, cards } = this.#options;
+		const line = await log.get(room, until);
+		if (!line || !isStartOver(line)) throw notFound();
+		const page = await log.page(room, before, count, until);
+		const first = page.messages[0];
+		const previous = page.more ? undefined : await log.startOver(room, until);
+		const from = page.more
+			? first?.at
+			: previous === undefined
+				? undefined
+				: (await log.get(room, previous))?.at;
+		return {
+			...page,
+			messages: withExpiredFiles(page.messages, this.#options.files),
+			cards: await cards.during(room, {
+				...(from === undefined ? {} : { from }),
+				before: before ?? until,
+			}),
+		};
+	}
+
 	/**
 	 * Reads the person's rooms up to their newest message in one call: the named ones, or every room
 	 * the list shows. A room they may not read is passed over as if it were not named. With `restore`

package/src/app/skill-doc-routes.ts

@@ -2,6 +2,7 @@ import type { SkillDocument, SkillRegistry } from "pi-roundtable";
 import { SkillConflictError } from "pi-roundtable";
 import type {
 	SkillConflict,
+	SkillDeleted,
 	SkillDocCreate,
 	SkillDocSave,
 	SkillDocView,
@@ -18,7 +19,11 @@ const MAX_SKILL_BYTES = 64 * 1024;
 export interface SkillDocApiOptions {
 	skills: Pick<
 		SkillRegistry,
-		"document" | "saveDocument" | "createDocument" | "documentHistory"
+		| "document"
+		| "saveDocument"
+		| "createDocument"
+		| "documentHistory"
+		| "delete"
 	>;
 	/** The catalog the page lists, so a name it does not list is a 404 before the registry is asked. */
 	catalog(): SkillView[];
@@ -34,7 +39,7 @@ const viewOf = (document: SkillDocument): SkillDocView => ({
 
 /**
  * The app's REST for a skill's SKILL.md: reading it whole, saving an agent-written skill's, making a
- * skill and listing the versions kept. The frontmatter rules are the skill tools': the registry
+ * skill, deleting an agent-written one and listing the versions kept. The frontmatter rules are the skill tools': the registry
  * checks them, and a refusal is a 400 with its words. Every call is an owner's; a save names the
  * hash it was edited from, and a skill that changed meanwhile answers 409 with what is there now.
  */
@@ -106,6 +111,11 @@ export class SkillDocApi {
 				throw error;
 			}
 		}
+		// The registry refuses a skill it did not write, in its own words; deleting detaches it from every carrier.
+		if (!action && method === "DELETE")
+			return json({
+				message: await skills.delete(name),
+			} satisfies SkillDeleted);
 		if (action === "history" && method === "GET" && parts.length === 4) {
 			return json({
 				versions: (await skills.documentHistory(name)).map((version) => ({

package/src/app/skill-group-routes.ts

@@ -0,0 +1,126 @@
+import type { SkillRegistry } from "pi-roundtable";
+import type {
+	SkillGroupApplied,
+	SkillGroupApply,
+	SkillGroupChanged,
+	SkillGroupSave,
+	SkillGroupsView,
+	SkillView,
+} from "../api-types.ts";
+import { json } from "../http.ts";
+import {
+	bad,
+	bodyOf,
+	HttpError,
+	optionalList,
+	optionalText,
+	requiredText,
+} from "./api-http.ts";
+import type { OwnerOf } from "./team-routes.ts";
+
+export interface SkillGroupApiOptions {
+	groups: Pick<SkillRegistry, "groups" | "setGroup" | "deleteGroup">;
+	/** The catalog the page lists: who carries each skill, and which are built in. */
+	catalog(): SkillView[];
+	/** The same change the per-skill toggle makes. */
+	attach(
+		agent: string,
+		add: readonly string[],
+		remove: readonly string[],
+	): Promise<string[]>;
+	/** Whether a knight answers; an archived or unknown one is a 404. */
+	active(agent: string): boolean;
+	changed(): void;
+}
+
+/**
+ * The app's REST for skill groups: listing them, creating or replacing one, deleting one, and
+ * applying one to a knight. Applying switches on the group's skills the knight lacks through the
+ * per-skill toggle's path; applying it off switches off the group's skills the knight carries, built-in
+ * ones excepted. The knight carries skills, not the group.
+ * Every call is an owner's; the registry's refusals are a 400 in its words.
+ */
+export class SkillGroupApi {
+	readonly #options: SkillGroupApiOptions;
+
+	constructor(options: SkillGroupApiOptions) {
+		this.#options = options;
+	}
+
+	async handle(
+		request: Request,
+		parts: string[],
+		owner: OwnerOf,
+	): Promise<Response> {
+		const { method } = request;
+		const [, , name, action] = parts;
+		const { groups } = this.#options;
+		// The tier is read first, so a person below the owner learns of no group.
+		await owner();
+		if (!name) {
+			if (method !== "GET") throw new HttpError(405, "Method not allowed.");
+			return json({
+				groups: groups.groups().map(({ name, description, skills }) => ({
+					name,
+					description,
+					skills: [...skills],
+				})),
+			} satisfies SkillGroupsView);
+		}
+		const group = groups.groups().find((one) => one.name === name);
+		if (!action && method === "PUT") {
+			const body = await bodyOf(request);
+			const from = optionalText(body, "from");
+			const save: SkillGroupSave = {
+				description: requiredText(body, "description"),
+				skills: optionalList(body, "skills") ?? [],
+				...(from ? { from } : {}),
+			};
+			const renamed = save.from !== undefined && save.from !== name;
+			if (renamed) {
+				if (!groups.groups().some((one) => one.name === save.from))
+					throw new HttpError(404, "There is no such skill group.");
+				if (group) throw bad(`There is already a skill group "${name}".`);
+			}
+			let message = await groups.setGroup(name, save.description, save.skills);
+			if (renamed && save.from)
+				message = `${message} ${await groups.deleteGroup(save.from)}`;
+			this.#options.changed();
+			return json({ message } satisfies SkillGroupChanged, group ? 200 : 201);
+		}
+		if (!group) throw new HttpError(404, "There is no such skill group.");
+		if (!action && method === "DELETE") {
+			const message = await groups.deleteGroup(name);
+			this.#options.changed();
+			return json({ message } satisfies SkillGroupChanged);
+		}
+		if (action === "apply" && method === "POST" && parts.length === 4) {
+			const body = await bodyOf(request);
+			const apply: SkillGroupApply = {
+				agent: requiredText(body, "agent"),
+				on: body.on !== false,
+			};
+			if (!this.#options.active(apply.agent))
+				throw new HttpError(404, "There is no such room, knight or file.");
+			const catalog = new Map(
+				this.#options.catalog().map((entry) => [entry.name, entry]),
+			);
+			// A built-in skill is carried always: it is never added nor switched off.
+			const switchable = group.skills.filter(
+				(skill) => catalog.get(skill)?.source.kind !== "builtin",
+			);
+			const carries = (skill: string) =>
+				catalog.get(skill)?.carriers.includes(apply.agent) ?? false;
+			const added = apply.on
+				? switchable.filter((skill) => !carries(skill))
+				: [];
+			const removed = apply.on ? [] : switchable.filter(carries);
+			if (added.length > 0 || removed.length > 0) {
+				await this.#options.attach(apply.agent, added, removed);
+				this.#options.changed();
+			}
+			return json({ added, removed } satisfies SkillGroupApplied);
+		}
+		throw new HttpError(404, "There is no such API.");
+	}
+}