pi-roundtable-web 0.27.0 → 0.28.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 {
@@ -15,7 +16,18 @@ import {
 	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";
@@ -176,12 +188,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,
@@ -207,11 +218,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),

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,7 +58,7 @@ 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 type { AppSurface } from "./surface.ts";
 import { TeamApi } from "./team-routes.ts";
@@ -79,12 +81,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,10 +133,14 @@ 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"
 		>;
 	};
 	/** Present when the host has prompt documents (the prompts plugin): the main prompts the owner edits. */
@@ -580,17 +586,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 +611,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 +638,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 +673,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/surface.ts

@@ -14,7 +14,12 @@ import {
 	roomOf,
 	type TurnProgress,
 } from "pi-roundtable";
-import type { RoomFile, RoomMessage, RoundView } from "../api-types.ts";
+import {
+	type RoomFile,
+	type RoomMessage,
+	type RoundView,
+	START_OVER_TEXT,
+} from "../api-types.ts";
 import type { OwnerDesk } from "./desk.ts";
 import { type FileBinding, type FileDir, typeByName } from "./files.ts";
 import type { NewRoomMessage, RoomLog } from "./room-log.ts";
@@ -314,6 +319,23 @@ export class AppSurface implements ChatSurface {
 	}
 
 	async sendReply(channel: ChannelKey, reply: OutboundReply): Promise<void> {
+		// A message between agents is a card beside the room's turn: it neither ends the turn nor
+		// names who speaks in it, and it notifies nobody.
+		if (reply.intercom) {
+			const { kind, peer, text } = reply.intercom;
+			await this.publish({
+				room: channel,
+				kind: "agent",
+				...(reply.author?.agent ? { agent: reply.author.agent } : {}),
+				author: reply.author?.name ?? ASSISTANT,
+				text,
+				intercom: {
+					kind,
+					peer: { name: peer.name, displayName: peer.displayName },
+				},
+			});
+			return;
+		}
 		this.#speaks(channel, reply.author?.agent);
 		const entry = this.#activity.get(channel);
 		if (entry) entry.outcome = reply.failed ? "failed" : "done";
@@ -357,7 +379,7 @@ export class AppSurface implements ChatSurface {
 			room: channel,
 			kind: "system",
 			author: ASSISTANT,
-			text: "Conversation started over",
+			text: START_OVER_TEXT,
 		});
 	}
 
@@ -367,6 +389,8 @@ export class AppSurface implements ChatSurface {
 
 	interim(channel: ChannelKey, as?: PostAuthor): InterimPosts {
 		return {
+			// The room's progress pane shows the tools a turn calls, so its live text leaves them out.
+			tools: false,
 			post: async (text) => {
 				this.#speaks(channel, as?.agent);
 				const live = crypto.randomUUID();

package/src/app/team-routes.ts

@@ -76,7 +76,7 @@ export interface TeamApiOptions {
 	log: Pick<RoomLog, "removeRoom">;
 	cards: Pick<CardLog, "removeRoom">;
 	mutes: Pick<PushMutes, "set">;
-	modes: Pick<ConversationModes, "set">;
+	modes: Pick<ConversationModes, "forget">;
 	/** The dispatch threads under a room, which go with it. */
 	threads: Pick<WebThreads, "under" | "removeUnder">;
 	/** The owners' shared arrangement, which drops a deleted room's pin and folder place. */
@@ -467,11 +467,7 @@ export class TeamApi {
 		await cards.removeRoom(room);
 		await mutes.set(room, false, by.principalId);
 		await layout.forget(room);
-		// A name made again later starts with the modes of a new room.
-		await modes.set(
-			room as ChannelKey,
-			{ yolo: false, longRunning: false },
-			by,
-		);
+		// A name made again later starts with the modes of a new room, and follows nothing.
+		await modes.forget(room as ChannelKey);
 	}
 }

package/src/authz.ts

@@ -42,6 +42,7 @@ export const ROUTES: readonly Rule[] = [
 	row("*", "api/skills", "O"),
 	row("*", "api/skills/:name", "O"),
 	row("*", "api/connectors", "O"),
+	row("*", "api/connectors/**", "O"),
 	row("*", "api/models", "O"),
 	// The owner's conversations; a member's own are filtered inside the handler.
 	row("*", "api/conversations", "V"),

package/src/cleanup-api.ts

@@ -22,10 +22,16 @@ export async function cleanupConversation(
 	const cleanup = features?.cleanup;
 	const key = raw as ChannelKey;
 	const parsed = parseKey(raw);
-	if (!cleanup || !parsed || parsed.kind === "group" || exclude?.(key))
-		throw new HttpError(404, "There is no such conversation.");
+	// An agent's or group's room in the web app is named by its room key, which no session directory has.
 	const owned =
 		Boolean(team?.owns(key)) || Boolean(features?.party?.contains(key));
+	if (
+		!cleanup ||
+		(!parsed && !owned) ||
+		parsed?.kind === "group" ||
+		exclude?.(key)
+	)
+		throw new HttpError(404, "There is no such conversation.");
 	const group =
 		(await team?.status())?.groups.some(
 			(g) => g.channelId !== undefined && `discord:${g.channelId}` === key,
@@ -33,6 +39,7 @@ export async function cleanupConversation(
 	const stored =
 		!owned &&
 		!group &&
+		parsed !== undefined &&
 		Boolean(conversationFiles(join(sessionsDir, parsed.dir)));
 	if (action === "delete") {
 		if (!stored)