pi-roundtable 0.26.3 → 0.27.1

package/src/core/routing/peer-bots.ts

@@ -0,0 +1,149 @@
+import {
+	either,
+	type Field,
+	integer,
+	list,
+	optional,
+	shape,
+	text,
+} from "../config/schema.ts";
+import type { InboundMessage } from "../contract/channels.ts";
+import { parseChannelKey } from "../contract/surface.ts";
+import { ConfigError } from "../domain/errors.ts";
+import type { ChannelKey } from "../sessions.ts";
+
+/** One peer bot the host answers, and where. */
+export interface PeerBotEntry {
+	/** The bot's user id on the surface, a Discord snowflake. */
+	id: string;
+	/** Answer it only in these servers; left out, in every server of the host. */
+	guilds?: readonly string[];
+	/** Answer it only in these channels; left out, in every channel. */
+	channels?: readonly string[];
+}
+
+/**
+ * The other bots whose messages the host answers like a guest's. Explicit ids only: there is no
+ * wildcard and no "all bots", and a host that leaves this out answers no bot.
+ */
+export interface PeerBotsConfig {
+	/** The peer bots, each by its user id or as an entry that limits it to servers or channels. */
+	allow: readonly (string | PeerBotEntry)[];
+	/**
+	 * The most messages from peer bots in a row, in one channel, that start a turn before the next
+	 * one is ignored; a person's message in the channel starts the count over. Default 3.
+	 */
+	maxRounds?: number;
+}
+
+/** The rounds in a row a channel answers peer bots when the host does not say. */
+export const DEFAULT_PEER_ROUNDS = 3;
+
+const SNOWFLAKE = /^[0-9]{17,20}$/;
+
+/** A Discord id: 17 to 20 digits. */
+const snowflake: Field<string> = {
+	describe: "a Discord id (17 to 20 digits)",
+	check: (value, path) => {
+		const id = text.check(value, path);
+		if (!SNOWFLAKE.test(id))
+			throw new ConfigError(
+				`config ${path}: expected a Discord id (17 to 20 digits), got ${JSON.stringify(id)}. Copy the id with Developer Mode on; a name or a wildcard is not accepted. Fix the value in roundtable.config.ts.`,
+			);
+		return id;
+	},
+};
+
+const entryShape = shape({
+	id: snowflake,
+	guilds: optional(list(snowflake)),
+	channels: optional(list(snowflake)),
+});
+
+/** `discord.peerBots`, or the `peerBots` of the host's options. */
+export const peerBotsShape = shape({
+	allow: list(either(snowflake, entryShape)),
+	maxRounds: optional(integer(1, 100)),
+});
+
+/**
+ * The peer bots a host answers, and how many of their messages in a row a channel answers.
+ * Core-internal: the router holds it, and a claim reads only `InboundMessage.peerBot`.
+ */
+export class PeerBots {
+	readonly #entries: ReadonlyMap<string, readonly PeerBotEntry[]>;
+	readonly #maxRounds: number;
+	readonly #surface: string;
+	/** Peer messages answered since a person last posted, by channel. */
+	readonly #rounds = new Map<ChannelKey, number>();
+
+	/** Throws a ConfigError naming `at` for an id that is not a snowflake. */
+	constructor(config: PeerBotsConfig, surface = "discord", at = "peerBots") {
+		const checked = peerBotsShape.check(config, at);
+		const entries = new Map<string, PeerBotEntry[]>();
+		for (const given of checked.allow) {
+			const entry = typeof given === "string" ? { id: given } : given;
+			entries.set(entry.id, [...(entries.get(entry.id) ?? []), entry]);
+		}
+		this.#entries = entries;
+		this.#maxRounds = checked.maxRounds ?? DEFAULT_PEER_ROUNDS;
+		this.#surface = surface;
+	}
+
+	/** Whether the host lists the bot that wrote this message, for this channel and server. */
+	lists(message: InboundMessage): boolean {
+		if (!message.authorIsBot || message.integration) return false;
+		const { surface, id: channelId } = parseChannelKey(message.channel);
+		if (surface !== this.#surface) return false;
+		return (this.#entries.get(message.authorId) ?? []).some(
+			(entry) =>
+				(!entry.guilds || entry.guilds.includes(message.space ?? "")) &&
+				(!entry.channels || entry.channels.includes(channelId)),
+		);
+	}
+
+	/** Whether the channel has answered its rounds of peer bots since a person last posted. */
+	exhausted(channel: ChannelKey): boolean {
+		return (this.#rounds.get(channel) ?? 0) >= this.#maxRounds;
+	}
+
+	/** Counts a peer bot's message the channel answered. */
+	answered(channel: ChannelKey): void {
+		this.#rounds.set(channel, (this.#rounds.get(channel) ?? 0) + 1);
+	}
+
+	/** A person posted in the channel: its rounds start over. */
+	personPosted(channel: ChannelKey): void {
+		this.#rounds.delete(channel);
+	}
+}
+
+/**
+ * Whether a claim that answers people may answer the author of this message: a person, or a bot
+ * the host lists as a peer (`discord.peerBots`) that mentions the bot or replies to it. Use it
+ * where a claim once checked `!message.authorIsBot`; the host's allowlist and rounds are already
+ * applied by the router, which alone sets `peerBot`. It says nothing of integrations and webhooks.
+ */
+export function answersAuthor(
+	message: Pick<
+		InboundMessage,
+		"authorIsBot" | "peerBot" | "mentionsBot" | "repliesToBot"
+	>,
+): boolean {
+	if (!message.authorIsBot) return true;
+	return (
+		message.peerBot === true && (message.mentionsBot || message.repliesToBot)
+	);
+}
+
+/**
+ * The message as a listed peer bot's reaches the access rules: without the server roles it holds,
+ * which a rule written for people could otherwise use to lift a bot above what its identity and
+ * `everyone` give.
+ */
+export function peerFacts(message: InboundMessage): InboundMessage {
+	const { authorRoleIds: _ids, actor, ...rest } = message;
+	if (!actor) return rest;
+	const { roles: _roles, ...bare } = actor;
+	return { ...rest, actor: bare };
+}

package/src/core/routing/surface-port.ts

@@ -60,10 +60,14 @@ export function surfacePort(
 			linked()
 				.filter((surface) => surface.agentRooms === true)
 				.map((surface) => surface.surface),
+		names: () => linked().map((surface) => surface.surface),
 		interim: (channel, as) => of(channel)?.interim?.(channel, as),
 		progress: async (channel, event) => {
 			await of(channel)?.progress?.(channel, event);
 		},
+		groupRound: async (channel, round) => {
+			await of(channel)?.groupRound?.(channel, round);
+		},
 	};
 }
 

package/src/core/services.ts

@@ -2,6 +2,8 @@ import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import type { CharacterInput, CharacterSpec } from "../characters/index.ts";
 import type { Agent, AgentGroup } from "./agents/agent-rules.ts";
 import type { AvatarMode } from "./agents/agent-tools.ts";
+import type { HelperTeam } from "./agents/helper-ops.ts";
+import type { RoutingTable } from "./agents/routes.ts";
 import type { TeamStatus } from "./agents/team-status.ts";
 import type { ChannelContexts } from "./contract/channel-context.ts";
 import type {
@@ -181,12 +183,12 @@ export interface AgentServer {
 	avatars: AvatarStudio;
 	/** Where the agents' files are: the directories their shell and file tools run in. */
 	workspace: AgentWorkspace;
+	routes?: RoutingTable; // where work no person started lands; the built-in server sets it
 }
 
 /**
  * The directories the agents work in, as configured. Every agent shares them: the core has no
- * workspace per agent. Read-only data, so a plugin that shows or serves the files can find them;
- * the directories may not exist yet.
+ * workspace per agent. Read-only data for a plugin that shows or serves the files; they may not exist yet.
  */
 export interface AgentWorkspace {
 	/** The shell's shared working directory (`config.workDir`), where agents write without a hold. */
@@ -241,9 +243,8 @@ export interface NewAgent {
 	/** Its opening task; without it the agent only exists. */
 	task?: string;
 	/**
-	 * The surface whose room the opening task runs in, so the person who asked sees it start
-	 * there. Without it, or for a surface that hosts no rooms, the task runs where `agent_create`
-	 * runs it: the agent's Discord channel, else its first room.
+	 * The surface whose room the opening task runs in, so the person who asked sees it start there;
+	 * without it, or for a surface with no rooms, where `agent_create` runs it: the agent's Discord channel, else its first room.
 	 */
 	openIn?: string;
 	category?: string;
@@ -262,7 +263,7 @@ export interface AgentChange {
 }
 
 /** The agent team as plugins use it: who is in it, what model they run, and their channels. */
-export interface AgentTeam {
+export interface AgentTeam extends HelperTeam {
 	/** The team's id: the Discord guild, or `"local"` on a host without Discord. */
 	readonly guildId: string;
 	/** Called when a turn starts or ends and when an agent or group changes. */

package/src/core/testing/fake-poster-guild.ts

@@ -32,7 +32,7 @@ export interface FakePosterMessage {
 	urls?: string[];
 	/** When it was posted, in the fake's own clock (one more for each message). */
 	at: number;
-	/** The card, for a message `sayCard` posted; `content` then holds its text. */
+	/** The card, for a message `sayCard` or `postCard` posted; `content` then holds its text. */
 	card?: DiscordCard;
 	/** Discord's message type; absent for an ordinary message, 6 for the notice a pin makes. */
 	type?: number;

package/src/core/testing/fake-poster-reads.ts

@@ -0,0 +1,96 @@
+import {
+	DISCORD_LIMITS,
+	type DiscordMessage,
+	type RecentMessage,
+} from "../discord/poster/poster.ts";
+import { checkSnowflake } from "../discord/poster/poster-checks.ts";
+import { DiscordPosterError } from "../discord/poster/poster-errors.ts";
+import { FakePosterGuild } from "./fake-poster-guild.ts";
+
+/** The fake's pin calls and message reads, on top of its channel, thread and member calls. */
+export abstract class FakePosterReads extends FakePosterGuild {
+	async pin(channelId: string, messageId: string): Promise<void> {
+		checkSnowflake("a channel", channelId);
+		checkSnowflake("a message", messageId);
+		this.sent("pin");
+		const channel = this.channel(channelId);
+		this.found(channelId, messageId);
+		if (channel.pins.includes(messageId)) return;
+		if (channel.pins.length >= DISCORD_LIMITS.pins)
+			throw new DiscordPosterError(
+				"rejected",
+				`a channel keeps at most ${DISCORD_LIMITS.pins} pins`,
+				{ discordCode: 30003, status: 400 },
+			);
+		channel.pins.push(messageId);
+		if (this.pinNotices) {
+			this.next += 1n;
+			channel.messages.push({
+				id: this.next.toString(),
+				username: "bot",
+				content: "",
+				files: [],
+				blobs: [],
+				mentions: [],
+				authorId: this.botId,
+				type: 6,
+				referencedMessageId: messageId,
+				at: this.tick(),
+			});
+		}
+	}
+
+	async unpin(channelId: string, messageId: string): Promise<void> {
+		checkSnowflake("a channel", channelId);
+		checkSnowflake("a message", messageId);
+		this.sent("unpin");
+		const channel = this.channel(channelId);
+		channel.pins = channel.pins.filter((id) => id !== messageId);
+	}
+
+	async pinnedIds(channelId: string): Promise<string[]> {
+		checkSnowflake("a channel", channelId);
+		this.sent("pinnedIds");
+		return [...this.channel(channelId).pins].reverse();
+	}
+
+	async message(channelId: string, messageId: string): Promise<DiscordMessage> {
+		checkSnowflake("a channel", channelId);
+		checkSnowflake("a message", messageId);
+		this.sent("message");
+		const found = this.found(channelId, messageId);
+		return {
+			id: found.id,
+			authorId: found.webhookId ?? found.authorId ?? "0",
+			...(found.webhookId ? { webhookId: found.webhookId } : {}),
+			content: found.content,
+			files: found.files.map((file, index) => ({
+				name: file.name,
+				contentType: found.blobs[index]?.contentType ?? "",
+				size: file.bytes,
+				url:
+					found.urls?.[index] ??
+					`https://cdn.test/${found.id}/${encodeURIComponent(file.name)}`,
+			})),
+		};
+	}
+
+	async recentMessages(
+		channelId: string,
+		limit: number,
+	): Promise<RecentMessage[]> {
+		checkSnowflake("a channel", channelId);
+		this.sent("recentMessages");
+		return [...this.channel(channelId).messages]
+			.reverse()
+			.slice(0, Math.min(50, Math.max(1, Math.trunc(limit))))
+			.map((message) => ({
+				id: message.id,
+				type: message.type ?? 0,
+				authorId: message.webhookId ?? message.authorId ?? "0",
+				...(message.referencedMessageId
+					? { referencedMessageId: message.referencedMessageId }
+					: {}),
+			}));
+	}
+}

package/src/core/testing/fake-poster.ts

@@ -1,16 +1,14 @@
-import {
-	DISCORD_LIMITS,
-	type DiscordCard,
-	type DiscordMessage,
-	type DiscordPoster,
-	type PostedMessage,
-	type RecentMessage,
+import type {
+	DiscordCard,
+	DiscordPoster,
+	PostedMessage,
 } from "../discord/poster/poster.ts";
 import {
 	cardBody,
 	checkAvatar,
 	checkedPost,
 	checkedText,
+	checkedWebhookCard,
 	checkSnowflake,
 	checkWebhookName,
 	invalid,
@@ -19,9 +17,9 @@ import { DiscordPosterError } from "../discord/poster/poster-errors.ts";
 import {
 	cardText,
 	type FakePosterChannel,
-	FakePosterGuild,
 	type FakePosterMessage,
 } from "./fake-poster-guild.ts";
+import { FakePosterReads } from "./fake-poster-reads.ts";
 
 export type {
 	FakePosterChannel,
@@ -108,7 +106,7 @@ export interface FakeDiscordPoster extends DiscordPoster {
  * the next call or to refuse direct messages from a person. The same scenarios run against it and
  * against the real poster over an emulated Discord, so the two answer alike.
  */
-class FakePosterImpl extends FakePosterGuild implements FakeDiscordPoster {
+class FakePosterImpl extends FakePosterReads implements FakeDiscordPoster {
 	readonly #webhooks = new Map<string, string>();
 	readonly #madeListeners = new Set<
 		(channelId: string, webhook: string) => Promise<void>
@@ -234,6 +232,61 @@ class FakePosterImpl extends FakePosterGuild implements FakeDiscordPoster {
 		message.mentions = body.allowed_mentions.users;
 	}
 
+	async postCard(
+		channelId: string,
+		post: Parameters<DiscordPoster["postCard"]>[1],
+	): Promise<PostedMessage> {
+		checkSnowflake("a channel", channelId);
+		const { webhook, body } = checkedWebhookCard(post);
+		this.sent("postCard");
+		const channel = this.channel(channelId);
+		const webhookId = await this.#webhook(channelId, webhook);
+		this.next += 1n;
+		const message: FakePosterMessage = {
+			id: this.next.toString(),
+			username: body.username,
+			content: cardText(post.card),
+			files: [],
+			blobs: [],
+			mentions: [],
+			...("avatar_url" in body ? { avatarUrl: body.avatar_url } : {}),
+			webhook,
+			webhookId,
+			card: post.card,
+			at: this.tick(),
+		};
+		channel.messages.push(message);
+		return { channelId, messageId: message.id };
+	}
+
+	async editWebhookCard(
+		channelId: string,
+		messageId: string,
+		card: DiscordCard,
+		webhooks: readonly string[],
+	): Promise<void> {
+		checkSnowflake("a channel", channelId);
+		checkSnowflake("a message", messageId);
+		cardBody(card);
+		for (const name of webhooks) checkWebhookName(name);
+		this.sent("editWebhookCard");
+		const message = this.found(channelId, messageId);
+		if (!webhooks.some((name) => this.#ownedBy(message, channelId, name)))
+			throw new DiscordPosterError(
+				"message_gone",
+				"the message does not exist",
+			);
+		// A message posted without the Components V2 flag cannot become a card.
+		if (!message.card)
+			throw new DiscordPosterError(
+				"rejected",
+				"editing a card failed: that message is not a card",
+				{ discordCode: 50035, status: 400 },
+			);
+		message.card = card;
+		message.content = cardText(card);
+	}
+
 	async remove(
 		channelId: string,
 		messageId: string,
@@ -375,91 +428,6 @@ class FakePosterImpl extends FakePosterGuild implements FakeDiscordPoster {
 		this.directs.push({ userId, content });
 		return "sent";
 	}
-
-	async pin(channelId: string, messageId: string): Promise<void> {
-		checkSnowflake("a channel", channelId);
-		checkSnowflake("a message", messageId);
-		this.sent("pin");
-		const channel = this.channel(channelId);
-		this.found(channelId, messageId);
-		if (channel.pins.includes(messageId)) return;
-		if (channel.pins.length >= DISCORD_LIMITS.pins)
-			throw new DiscordPosterError(
-				"rejected",
-				`a channel keeps at most ${DISCORD_LIMITS.pins} pins`,
-				{ discordCode: 30003, status: 400 },
-			);
-		channel.pins.push(messageId);
-		if (this.pinNotices) {
-			this.next += 1n;
-			channel.messages.push({
-				id: this.next.toString(),
-				username: "bot",
-				content: "",
-				files: [],
-				blobs: [],
-				mentions: [],
-				authorId: this.botId,
-				type: 6,
-				referencedMessageId: messageId,
-				at: this.tick(),
-			});
-		}
-	}
-
-	async unpin(channelId: string, messageId: string): Promise<void> {
-		checkSnowflake("a channel", channelId);
-		checkSnowflake("a message", messageId);
-		this.sent("unpin");
-		const channel = this.channel(channelId);
-		channel.pins = channel.pins.filter((id) => id !== messageId);
-	}
-
-	async pinnedIds(channelId: string): Promise<string[]> {
-		checkSnowflake("a channel", channelId);
-		this.sent("pinnedIds");
-		return [...this.channel(channelId).pins].reverse();
-	}
-
-	async message(channelId: string, messageId: string): Promise<DiscordMessage> {
-		checkSnowflake("a channel", channelId);
-		checkSnowflake("a message", messageId);
-		this.sent("message");
-		const found = this.found(channelId, messageId);
-		return {
-			id: found.id,
-			authorId: found.webhookId ?? found.authorId ?? "0",
-			...(found.webhookId ? { webhookId: found.webhookId } : {}),
-			content: found.content,
-			files: found.files.map((file, index) => ({
-				name: file.name,
-				contentType: found.blobs[index]?.contentType ?? "",
-				size: file.bytes,
-				url:
-					found.urls?.[index] ??
-					`https://cdn.test/${found.id}/${encodeURIComponent(file.name)}`,
-			})),
-		};
-	}
-
-	async recentMessages(
-		channelId: string,
-		limit: number,
-	): Promise<RecentMessage[]> {
-		checkSnowflake("a channel", channelId);
-		this.sent("recentMessages");
-		return [...this.channel(channelId).messages]
-			.reverse()
-			.slice(0, Math.min(50, Math.max(1, Math.trunc(limit))))
-			.map((message) => ({
-				id: message.id,
-				type: message.type ?? 0,
-				authorId: message.webhookId ?? message.authorId ?? "0",
-				...(message.referencedMessageId
-					? { referencedMessageId: message.referencedMessageId }
-					: {}),
-			}));
-	}
 }
 
 /** A `DiscordPoster` in memory, to give a plugin under test as `DISCORD.poster`. */

package/src/core/tool-set.snapshot.json

@@ -89,6 +89,8 @@
 				"discord_unpin_message",
 				"group_create",
 				"group_update",
+				"helper_create",
+				"helper_end",
 				"memory_add",
 				"memory_remove",
 				"memory_search",
@@ -121,6 +123,8 @@
 				"edit",
 				"group_create",
 				"group_update",
+				"helper_create",
+				"helper_end",
 				"message_agent",
 				"read",
 				"skill_create",
@@ -179,6 +183,8 @@
 				"discord_unpin_message",
 				"group_create",
 				"group_update",
+				"helper_create",
+				"helper_end",
 				"memory_add",
 				"memory_remove",
 				"memory_search",
@@ -273,6 +279,8 @@
 		"get_search_content": "member",
 		"group_create": "admin",
 		"group_update": "admin",
+		"helper_create": "member",
+		"helper_end": "member",
 		"memory_add": "member",
 		"memory_remove": "member",
 		"memory_search": "member",

package/src/discord/index.ts

@@ -81,6 +81,7 @@ export {
 export type {
 	CardButton,
 	CardLink,
+	CardPicture,
 	CardSelect,
 	CategoryChannel,
 	DiscordCard,
@@ -93,6 +94,7 @@ export type {
 	RecentMessage,
 	ThreadCloser,
 	ThreadState,
+	WebhookCardPost,
 	WebhookPost,
 } from "../core/discord/poster/poster.ts";
 export {

package/src/index.ts

@@ -4,7 +4,7 @@ export {
 	AGENT_SERVER_PRIORITY,
 	OWNER_TARGET,
 } from "./core/agents/agent-claim.ts";
-export { characterOf } from "./core/agents/agent-rules.ts";
+export { characterOf, isHelper } from "./core/agents/agent-rules.ts";
 export type {
 	Agent,
 	AgentGroup,
@@ -12,6 +12,8 @@ export type {
 	AgentStatus,
 } from "./core/agents/agent-store.ts";
 export type { AvatarMode } from "./core/agents/agent-tools.ts";
+export type { HelpersEnded, HelperTeam } from "./core/agents/helper-ops.ts";
+export type { RouteKind, RoutingTable } from "./core/agents/routes.ts";
 export {
 	agentRoomKey,
 	groupRoomKey,
@@ -48,8 +50,15 @@ export type {
 	TierConfig,
 } from "./core/config/config.ts";
 export type { ConversationsConfig } from "./core/config/conversations.ts";
+export type { HelpersConfig } from "./core/config/helpers.ts";
 export type { LimitsConfig } from "./core/config/limits.ts";
 export type { ProfilesConfig } from "./core/config/profiles.ts";
+export type {
+	AgentRoutes,
+	PlaceTarget,
+	RoutingConfig,
+	SurfaceRouting,
+} from "./core/config/routing.ts";
 export type { SkillsConfig } from "./core/config/skills-config.ts";
 export type {
 	AttachmentPort,
@@ -78,6 +87,8 @@ export type {
 	ConversationKind,
 	ConversationPort,
 	InboundMessage,
+	MessageObserver,
+	ObserveFilter,
 	QueuePort,
 	ScheduledOutcome,
 } from "./core/contract/channels.ts";
@@ -101,6 +112,7 @@ export type { ServiceKey, Services } from "./core/contract/services.ts";
 export { serviceKey } from "./core/contract/services.ts";
 export type {
 	ChatSurface,
+	SurfaceMessageEvents,
 	SurfacePort,
 	SurfaceThreads,
 } from "./core/contract/surface.ts";
@@ -163,6 +175,7 @@ export type {
 } from "./core/domain/interim.ts";
 export type { TurnConversation, TurnRequest } from "./core/domain/ports.ts";
 export type { HoldRefusal, TurnProgress } from "./core/domain/progress.ts";
+export type { RoundEnd, RoundProgress } from "./core/domain/round.ts";
 export {
 	type TurnLimit,
 	type TurnTimeout,
@@ -355,6 +368,10 @@ export type {
 	ConversationTurnInput,
 	ConversationTurns,
 } from "./core/routing/conversation-turns.ts";
+export type {
+	PeerBotEntry,
+	PeerBotsConfig,
+} from "./core/routing/peer-bots.ts";
 export type {
 	AgentChange,
 	AgentDirectory,

package/src/kit/channels.ts

@@ -18,4 +18,5 @@ export { attachmentsOf } from "../core/attachments/turn-attachments.ts";
 export type { ChannelQueue } from "../core/routing/channel-queue.ts";
 export { channelQueue } from "../core/routing/channel-queue.ts";
 export { withReference } from "../core/routing/message-text.ts";
+export { answersAuthor } from "../core/routing/peer-bots.ts";
 export { outcome, settleTurn } from "../core/routing/settle-turn.ts";

package/src/kit/index.ts

@@ -2,6 +2,7 @@
 
 export type { ChannelQueue } from "./channels.ts";
 export {
+	answersAuthor,
 	attachmentsOf,
 	channelQueue,
 	channelSegment,
@@ -118,9 +119,13 @@ export {
 } from "./mirror.ts";
 export { oidcIdentity, oidcProvider } from "./oidc.ts";
 export type {
+	OpsAlert,
 	OpsAlertKind,
 	OpsAlertsOptions,
 	OpsRaiseOptions,
+	OpsResolution,
+	OpsSeverity,
+	OpsSink,
 } from "./ops-alerts.ts";
 export { OpsAlerts } from "./ops-alerts.ts";
 export {

package/src/kit/ops-alerts.ts

@@ -2,8 +2,12 @@
 // Short alerts for the people who run a host, held to a window so a fault cannot flood them.
 
 export type {
+	OpsAlert,
 	OpsAlertKind,
 	OpsAlertsOptions,
 	OpsRaiseOptions,
+	OpsResolution,
+	OpsSeverity,
+	OpsSink,
 } from "../core/ops/ops-alerts.ts";
 export { OpsAlerts } from "../core/ops/ops-alerts.ts";