pi-roundtable 0.1.0 → 0.2.0

package/src/core/agents/team-turns.test.ts

@@ -1,278 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { NO_ATTACHMENTS } from "../domain/attachment.ts";
-import type {
-	PendingConfirmation,
-	TurnResult,
-} from "../domain/conversation.ts";
-import { AgentRunError } from "../domain/errors.ts";
-import type { AgentTurnScope, TurnRequest } from "../domain/ports.ts";
-import { messages } from "../i18n/index.ts";
-import { silentLogger } from "../log.ts";
-import { ChannelQueue } from "../routing/channel-queue.ts";
-import { TEST_OWNER as OWNER, OWNER_SPEAKER } from "../testing/owner.ts";
-import { FakeThreadHost, fakeThreads } from "../testing/thread-host.ts";
-import type { AgentPost } from "./agent-ports.ts";
-import type { Agent, AgentGroup, AgentStore } from "./agent-store.ts";
-import { channelKey } from "./team-keys.ts";
-import { TeamTurns } from "./team-turns.ts";
-
-const agent = (name: string, channelId: string): Agent => ({
-	name,
-	displayName: name === "infra" ? "Infrastructure" : "Coordinator",
-	prompt: "",
-	avatarPrompt: "",
-	channelId,
-	status: "active",
-});
-
-const AGENTS = [agent("coordinator", "1000"), agent("infra", "2000")];
-const GROUP: AgentGroup = {
-	name: "ops",
-	displayName: "Ops",
-	channelId: "3000",
-	members: ["coordinator", "infra"],
-	host: "coordinator",
-	status: "active",
-};
-
-/** The store methods messages between agents read, over two agents and one group. */
-const store = {
-	agent: (name: string) => AGENTS.find((a) => a.name === name),
-	activeAgent: (name: string) => {
-		const found = AGENTS.find((a) => a.name === name);
-		if (!found) throw new Error(`no agent ${name}`);
-		return found;
-	},
-	agentByChannel: (id: string) => AGENTS.find((a) => a.channelId === id),
-	group: (name: string) => (name === GROUP.name ? GROUP : undefined),
-	groupByChannel: (id: string) => (id === GROUP.channelId ? GROUP : undefined),
-} as unknown as AgentStore;
-
-const coordinator: AgentTurnScope = {
-	name: "coordinator",
-	session: channelKey("1000"),
-	home: channelKey("1000"),
-};
-
-function setup(
-	answer: (request: TurnRequest) => TurnResult,
-	host = new FakeThreadHost(),
-	withThreads = true,
-	held?: PendingConfirmation,
-) {
-	const posts: { channelId: string; post: AgentPost }[] = [];
-	const turns: TurnRequest[] = [];
-	/** The replies the judge was asked to read as approvals. */
-	const judged: string[] = [];
-	const { threads } = fakeThreads(host);
-	const queue = new ChannelQueue();
-	const team = new TeamTurns({
-		owner: OWNER,
-		entryChannelId: "1000",
-		store,
-		channels: {
-			post: async (channelId, post) => {
-				posts.push({ channelId, post });
-			},
-		},
-		studio: { url: () => "https://x/a.png" },
-		runtime: () => ({
-			runTurn: async (request) => {
-				turns.push(request);
-				return answer(request);
-			},
-			heldActions: async () => held,
-			startFresh: async () => undefined,
-			contextUsage: () => undefined,
-		}),
-		selection: () => ({ id: "agent", tools: [], groups: [] }),
-		confirmations: {
-			approves: async (_pending, reply) => {
-				judged.push(reply);
-				return true;
-			},
-		},
-		scorer: { score: async () => undefined },
-		queue,
-		startTyping: () => () => undefined,
-		showStop: () => () => undefined,
-		logger: silentLogger(),
-		changed: () => undefined,
-		...(withThreads ? { threads } : {}),
-	});
-	/** Posts in a channel, or in one of its threads, as `name: text`. */
-	const texts = (channelId: string, threadId?: string) =>
-		posts
-			.filter((p) => p.channelId === channelId && p.post.threadId === threadId)
-			.map((p) => `${p.post.name}: ${p.post.chunks.join("")}`);
-	return { team, host, posts, turns, texts, judged };
-}
-
-/** Runs a coordinator turn, whose model sends the message, and waits for the chain to settle. */
-async function run(team: TeamTurns): Promise<void> {
-	await team.answerBackground(channelKey("1000"), OWNER_SPEAKER, "go");
-	for (let i = 0; i < 30; i++) await Bun.sleep(2);
-}
-
-describe("message_agent threads", () => {
-	test("the exchange goes in a thread of the sender's channel, archived before the sender's follow-up", async () => {
-		let archivedAtFollowUp: string[] | undefined;
-		const host = new FakeThreadHost();
-		const { team, texts, turns } = setup((request) => {
-			if (request.agent?.name === "coordinator" && turns.length === 1)
-				team.message(coordinator, "infra", "check the disk");
-			if (request.agent?.name === "coordinator" && turns.length > 1)
-				archivedAtFollowUp = [...host.closed];
-			return {
-				ok: true,
-				text: request.agent?.name === "infra" ? "disk 80%" : "ok",
-			};
-		}, host);
-		await run(team);
-		expect(host.opened).toEqual([
-			{ parentId: "1000", name: "→ Infrastructure", id: "900" },
-		]);
-		expect(host.lines.get("1000")).toBe(
-			messages().threadStarted("→ Infrastructure", "<#900>"),
-		);
-		expect(texts("1000", "900")).toEqual([
-			`Coordinator: ${messages().messageDelivered("Infrastructure", "check the disk")}`,
-			`Infrastructure: ${messages().answerReturned("disk 80%")}`,
-		]);
-		// The target's own channel is unchanged; the sender's channel holds only its own replies.
-		expect(texts("2000")).toEqual([
-			`Coordinator: ${messages().messageDelivered("Infrastructure", "check the disk")}`,
-			"Infrastructure: disk 80%",
-		]);
-		expect(texts("1000")).toEqual(["Coordinator: ok", "Coordinator: ok"]);
-		expect(archivedAtFollowUp).toEqual(["900"]);
-		const followUp = turns.at(-1);
-		expect(followUp?.channel).toBe(channelKey("1000"));
-		expect(followUp?.text).toContain("in the thread <#900>");
-		expect(followUp?.text).toContain("disk 80%"); // Only the answer's follow-up is a report turn, which may ask the owner on cards.
-		expect(turns.map((t) => [t.agent?.name, t.interactive])).toEqual([
-			["coordinator", undefined],
-			["infra", undefined],
-			["coordinator", true],
-		]);
-	});
-
-	test("a report turn in an agent's channel may ask on cards; a schedule's may not", async () => {
-		const { team, turns } = setup(() => ({ ok: true, text: "ok" }));
-		await team.answerBackground(channelKey("1000"), OWNER_SPEAKER, "scheduled");
-		await team.answerBackground(
-			channelKey("1000"),
-			OWNER_SPEAKER,
-			"report",
-			true,
-		);
-		expect(turns.map((t) => t.interactive)).toEqual([undefined, true]);
-	});
-
-	test("a failed or stopped answer is reported in the thread, which is archived", async () => {
-		const { team, host, turns } = setup((request) => {
-			if (request.agent?.name === "coordinator" && turns.length === 1)
-				team.message(coordinator, "infra", "x");
-			return request.agent?.name === "infra"
-				? {
-						ok: false,
-						error: new AgentRunError("stopped by the owner"),
-						stopped: true,
-					}
-				: { ok: true, text: "ok" };
-		});
-		await run(team);
-		expect(host.textsIn("900")).toEqual([
-			messages().agentNoReply("stopped by the owner"),
-		]);
-		expect(host.closed).toEqual(["900"]);
-		expect(turns.at(-1)?.text).toContain("could not answer");
-		expect(turns.at(-1)?.text).toContain("<#900>");
-	});
-
-	test("without a thread the answer comes back in the sender's channel as before", async () => {
-		const host = new FakeThreadHost();
-		host.failOpen = true;
-		const { team, texts, turns } = setup((request) => {
-			if (request.agent?.name === "coordinator" && turns.length === 1)
-				team.message(coordinator, "infra", "x");
-			return { ok: true, text: `${request.agent?.name} ok` };
-		}, host);
-		await run(team);
-		expect(texts("1000")).toContain(
-			`Infrastructure: ${messages().answerReturned("infra ok")}`,
-		);
-		expect(turns.at(-1)?.text).not.toContain("thread");
-	});
-
-	test("a group round's dispatches open their threads in the group channel", () => {
-		const { team } = setup(() => ({ ok: true, text: "" }), undefined, false);
-		expect(team.turnChannel({ ...coordinator, group: "ops" })).toBe(
-			channelKey("3000"),
-		);
-		expect(team.turnChannel(coordinator)).toBe(channelKey("1000"));
-	});
-});
-
-describe("speakers", () => {
-	test("a message chain keeps the speaker who started it through every hop", async () => {
-		const admin = { id: "2", name: "Ada", tier: "admin" } as const;
-		const { team, turns } = setup((request) => {
-			if (request.agent?.name === "coordinator" && turns.length === 1)
-				team.message(coordinator, "infra", "check the disk");
-			return { ok: true, text: "ok" };
-		});
-		await team.answerBackground(channelKey("1000"), admin, "go");
-		for (let i = 0; i < 30; i++) await Bun.sleep(2);
-		expect(turns.map((t) => [t.agent?.name, t.speaker])).toEqual([
-			["coordinator", admin],
-			["infra", admin],
-			["coordinator", admin],
-		]);
-	});
-});
-
-describe("approvals", () => {
-	const shell: PendingConfirmation = {
-		profile: "general",
-		heldAt: new Date(),
-		calls: [{ tool: "bash", input: "{}", action: "run a command" }],
-	};
-	const answer = () => ({ ok: true, text: "ok" }) as const;
-	const reply = (
-		team: TeamTurns,
-		tier: "owner" | "admin" | "member",
-	): Promise<unknown> =>
-		team.answerOwner(
-			channelKey("1000"),
-			{ id: "2", name: "Ada", tier },
-			"yes, run it",
-			"yes, run it",
-			NO_ATTACHMENTS,
-		);
-
-	test("a speaker whose tier holds the held tool approves it", async () => {
-		const { team, turns, judged } = setup(answer, undefined, true, shell);
-		await reply(team, "owner");
-		expect(judged).toEqual(["yes, run it"]);
-		expect(turns[0]?.confirmed).toBe(true);
-	});
-
-	test("a lower tier is not asked to approve, so the held action stays held", async () => {
-		const { team, turns, judged } = setup(answer, undefined, true, shell);
-		await reply(team, "admin");
-		await reply(team, "member");
-		expect(judged).toEqual([]);
-		expect(turns.map((t) => t.confirmed)).toEqual([undefined, undefined]);
-	});
-
-	test("an admin approves what an admin may use", async () => {
-		const held: PendingConfirmation = {
-			...shell,
-			calls: [{ tool: "agent_create", input: "{}", action: "create an agent" }],
-		};
-		const { team, turns } = setup(answer, undefined, true, held);
-		await reply(team, "admin");
-		expect(turns[0]?.confirmed).toBe(true);
-	});
-});

package/src/core/attachments/attachments.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createCanvas, loadImage } from "canvas";
-import { NO_ATTACHMENTS } from "../domain/attachment.ts";
-import { readAttachment } from "../shared/attachment-reader.ts";
-import { safeFileName } from "./attachment-fetcher.ts";
-import { prepareImage } from "./image-prep.ts";
-import { withAttachmentsBlock } from "./prompt-block.ts";
-
-const dir = mkdtempSync(join(tmpdir(), "roundtable-read-"));
-
-describe("safeFileName", () => {
-	test("keeps names readable and strips path parts", () => {
-		expect(safeFileName("отчёт v2.pdf")).toBe("отчёт v2.pdf");
-		expect(safeFileName("../../etc/passwd")).toBe("__.._etc_passwd");
-		expect(safeFileName("")).toBe("file");
-	});
-});
-
-describe("prepareImage", () => {
-	test("an image over the side limit is downscaled to 2,000 px JPEG", async () => {
-		const canvas = createCanvas(9000, 100);
-		const path = join(dir, "wide.png");
-		await Bun.write(path, canvas.toBuffer("image/png"));
-		const image = await prepareImage({ path, contentType: "image/png" });
-		expect(image.mimeType).toBe("image/jpeg");
-		const decoded = await loadImage(Buffer.from(image.data, "base64"));
-		expect(decoded.width).toBe(2000);
-	});
-});
-
-describe("readAttachment", () => {
-	test("reads text in pieces and refuses paths and binaries", async () => {
-		await Bun.write(join(dir, "a.txt"), "x".repeat(70_000));
-		const first = await readAttachment(dir, "a.txt");
-		expect(first.text).toHaveLength(60_000);
-		expect(first.total).toBe(70_000);
-		expect((await readAttachment(dir, "a.txt", 60_000)).text).toHaveLength(
-			10_000,
-		);
-		await expect(readAttachment(dir, "../a.txt")).rejects.toThrow(
-			"not an attachment name",
-		);
-		await Bun.write(join(dir, "b.bin"), new Uint8Array([0, 1, 2, 255]));
-		await expect(readAttachment(dir, "b.bin")).rejects.toThrow(
-			"not a text or PDF file",
-		);
-		await expect(readAttachment(dir, "none.txt")).rejects.toThrow(
-			"no attachment named",
-		);
-	});
-});
-
-describe("withAttachmentsBlock", () => {
-	test("adds nothing without attachments", () => {
-		expect(withAttachmentsBlock("hi", NO_ATTACHMENTS)).toBe("hi");
-	});
-
-	test("lists files and failures", () => {
-		const text = withAttachmentsBlock("hi", {
-			files: [
-				{
-					name: "a.pdf",
-					file: "m-0-a.pdf",
-					path: "/x",
-					contentType: "application/pdf",
-					size: 2048,
-					fromReference: false,
-				},
-			],
-			images: [],
-			failures: [
-				{ name: "b.mov", reason: "larger than 25 MB", fromReference: true },
-			],
-		});
-		expect(text).toContain(
-			'- m-0-a.pdf (original name "a.pdf", application/pdf, 2 KB)',
-		);
-		expect(text).toContain(
-			'"b.mov" from the replied-to message could not be received: larger than 25 MB',
-		);
-	});
-});

package/src/core/boundary.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { readdirSync, readFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-
-const ROOT = resolve(import.meta.dir, "../..");
-const CORE = join(ROOT, "src/core");
-
-function coreFiles(dir: string): string[] {
-	return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
-		const path = join(dir, entry.name);
-		if (entry.isDirectory()) return coreFiles(path);
-		return entry.name.endsWith(".ts") ? [path] : [];
-	});
-}
-
-/** Relative imports of a file, as repository paths. */
-function localImports(file: string): string[] {
-	const source = readFileSync(file, "utf8");
-	return [...source.matchAll(/from\s+"(\.{1,2}\/[^"]+)"/g)].map((match) =>
-		relative(ROOT, resolve(dirname(file), match[1] ?? "")),
-	);
-}
-
-describe("core boundary", () => {
-	test("the core imports only itself", () => {
-		const outside = coreFiles(CORE).flatMap((file) =>
-			localImports(file)
-				.filter((path) => !path.startsWith("src/core/"))
-				.map((path) => `${relative(ROOT, file)} -> ${path}`),
-		);
-		expect(outside).toEqual([]);
-	});
-
-	test("the core never imports a consumer's plugins", () => {
-		const consumers = readdirSync(join(ROOT, "src"), { withFileTypes: true })
-			.filter((entry) => entry.isDirectory() && entry.name !== "core")
-			.map((entry) => `src/${entry.name}/`);
-		const found = coreFiles(CORE).flatMap((file) =>
-			localImports(file).filter((path) =>
-				consumers.some((prefix) => path.startsWith(prefix)),
-			),
-		);
-		expect(found).toEqual([]);
-	});
-});

package/src/core/builtin/modules.test.ts

@@ -1,127 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-	ExtensionAPI,
-	ExtensionFactory,
-} from "@earendil-works/pi-coding-agent";
-import {
-	type AgentTurnScope,
-	type ChannelKey,
-	compileSessionPlan,
-	type SessionContext,
-} from "../sessions.ts";
-import { OWNER_CHANNEL, setUpModules } from "../testing/modules.ts";
-
-const HOME: ChannelKey = "discord:scout";
-const GROUP: ChannelKey = "discord:war-room";
-const OUTSIDE: ChannelKey = "party:table-1";
-
-const scout: AgentTurnScope = { name: "scout", session: HOME, home: HOME };
-const seat: AgentTurnScope = {
-	name: "scout",
-	session: GROUP,
-	home: HOME,
-	group: "war-room",
-};
-
-function context(agent?: AgentTurnScope, home?: ChannelKey): SessionContext {
-	const session: SessionContext = {
-		kind: agent ? "agent" : "owner",
-		homeChannel: home ?? agent?.home ?? OWNER_CHANNEL,
-		turnChannel: agent?.session ?? home ?? OWNER_CHANNEL,
-		compaction: { wrap: (compactor) => compactor },
-		speaker: () => undefined,
-		runTask: async () => "report",
-	};
-	if (agent) session.agent = agent;
-	return session;
-}
-
-interface Registered {
-	name: string;
-	parameters: { properties: Record<string, unknown> };
-	execute(
-		id: string,
-		params: unknown,
-	): Promise<{ content: { text: string }[]; isError?: boolean }>;
-}
-
-/** The tools one of the modules' extensions registers in a session. */
-async function registered(
-	setup: Awaited<ReturnType<typeof setUpModules>>,
-	session: SessionContext,
-	extension: string,
-): Promise<Registered[]> {
-	const tool = setup.contribution.sessionTools?.find(
-		(candidate) => candidate.name === extension,
-	);
-	const factory: ExtensionFactory | null | undefined = tool
-		?.snapshot()
-		.factory(session);
-	if (!factory) throw new Error(`no ${extension} extension`);
-	const tools: Registered[] = [];
-	await factory({
-		registerTool: (definition: Registered) => tools.push(definition),
-		on: () => undefined,
-	} as unknown as ExtensionAPI);
-	return tools;
-}
-
-describe("modulesPlugin", () => {
-	test("adds the owner's tools in a fixed order, and the delegator to the shutdown drain", async () => {
-		const setup = await setUpModules();
-		const { sessionTools, services } = setup.contribution;
-		expect(sessionTools?.map((tool) => tool.name)).toEqual([
-			"owner-memory",
-			"notify",
-			"schedules",
-			"delegate",
-			"discord-admin",
-		]);
-		expect(sessionTools?.every((tool) => tool.phase === "tools")).toBe(true);
-		expect(services?.map((service) => service.name)).toEqual(["delegator"]);
-		expect(compileSessionPlan(sessionTools ?? []).tools).toHaveLength(5);
-	});
-
-	test("provides the background turns and the delegator to the plugins after it", async () => {
-		const { core } = await setUpModules();
-		expect(core.background).toBeDefined();
-		expect(core.delegator.runningChannels()).toEqual([]);
-	});
-
-	test("delegate_task reports home and opens its thread in the group", async () => {
-		const setup = await setUpModules();
-		const [delegate] = await registered(setup, context(seat), "delegate");
-		await delegate?.execute("1", { title: "t", task: "look it up" });
-		await setup.core.delegator.idle();
-		expect(setup.record.reportChannels).toEqual([HOME]);
-		expect(setup.record.threadOrigins).toEqual([GROUP]);
-		expect(setup.record.ownerChannelAsked).toBe(0);
-	});
-
-	test("a conversation without a chat channel reports in the owner's messages", async () => {
-		const setup = await setUpModules();
-		const [delegate] = await registered(
-			setup,
-			context(undefined, OUTSIDE),
-			"delegate",
-		);
-		await delegate?.execute("1", { title: "t", task: "look it up" });
-		await setup.core.delegator.idle();
-		expect(setup.record.reportChannels).toEqual([OWNER_CHANNEL]);
-		expect(setup.record.ownerChannelAsked).toBe(1);
-	});
-
-	test("only agent sessions may read another agent's schedules", async () => {
-		const setup = await setUpModules({ agentChannelOf: () => HOME });
-		const list = async (session: SessionContext) =>
-			(await registered(setup, session, "schedules")).find(
-				(tool) => tool.name === "schedule_list",
-			);
-		expect(
-			Object.keys((await list(context(scout)))?.parameters.properties ?? {}),
-		).toContain("agent");
-		expect(
-			Object.keys((await list(context()))?.parameters.properties ?? {}),
-		).not.toContain("agent");
-	});
-});

package/src/core/config/config.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ConfigError } from "../domain/errors.ts";
-import { type RoundtableConfig, resolveConfig } from "./config.ts";
-
-const minimal: RoundtableConfig = {
-	owner: { id: "100000000000000001", name: "Ada" },
-	discord: {
-		token: "token",
-		guild: "900000000000000001",
-		entryChannel: "900000000000000002",
-	},
-	database: { url: "postgres://localhost/roundtable" },
-	dataDir: "/data",
-	model: "anthropic/claude-sonnet-5-5",
-	http: { publicUrl: "https://bot.example.com" },
-};
-
-const refused = (input: unknown): string => {
-	try {
-		resolveConfig(input);
-	} catch (error) {
-		if (error instanceof ConfigError) return error.message;
-		throw error;
-	}
-	return "";
-};
-
-describe("resolveConfig", () => {
-	test("fills every default from a minimal configuration", () => {
-		const config = resolveConfig(minimal);
-		expect(config.name).toBe("Roundtable");
-		expect(config.owner).toEqual({
-			id: "100000000000000001",
-			name: "Ada",
-			pronouns: { subject: "they", object: "them", possessive: "their" },
-		});
-		expect(config.discord.rootCommand).toBe("roundtable");
-		expect(config.agentDir).toBe("/data/pi");
-		expect(config.model).toEqual({
-			provider: "anthropic",
-			id: "claude-sonnet-5-5",
-		});
-		expect(config.thinking).toBe("medium");
-		expect(config.judge).toEqual({ model: config.model, threshold: 0.6 });
-		expect(config.delegation).toEqual({
-			model: config.model,
-			thinking: "medium",
-		});
-		expect(config.locale).toBe("en");
-		expect(config.timeZone).toBe("UTC");
-		expect(config.http.port).toBe(3000);
-		expect(config.agents).toEqual([]);
-		expect(config.plugins).toEqual([]);
-	});
-
-	test("the root command follows the assistant's name unless one is given", () => {
-		expect(
-			resolveConfig({ ...minimal, name: "Robin Hood" }).discord.rootCommand,
-		).toBe("robin-hood");
-		expect(
-			resolveConfig({
-				...minimal,
-				discord: { ...minimal.discord, rootCommand: "rh" },
-			}).discord.rootCommand,
-		).toBe("rh");
-	});
-
-	test("pronouns become the words prompts use", () => {
-		const owner = { ...minimal.owner, pronouns: "she" as const };
-		expect(resolveConfig({ ...minimal, owner }).owner.pronouns).toEqual({
-			subject: "she",
-			object: "her",
-			possessive: "her",
-		});
-	});
-
-	test("an unknown key names the nearest known key, at any depth", () => {
-		expect(refused({ ...minimal, discrod: {} })).toStartWith(
-			'config discrod: unknown key. Did you mean "discord"? The keys here are name, owner, discord,',
-		);
-		expect(
-			refused({ ...minimal, discord: { ...minimal.discord, tokn: "x" } }),
-		).toContain('config discord.tokn: unknown key. Did you mean "token"?');
-	});
-
-	test("a missing required key names it and the fix", () => {
-		const { model: _model, ...without } = minimal;
-		expect(refused(without)).toBe(
-			"config model: required, expected a non-empty string. Add it to roundtable.config.ts.",
-		);
-		expect(refused({ ...minimal, owner: { name: "Ada" } })).toBe(
-			"config owner.id: required, expected a non-empty string. Add it to roundtable.config.ts.",
-		);
-	});
-
-	test("a wrong value says what was expected and what it got", () => {
-		expect(refused({ ...minimal, thinking: "loud" })).toBe(
-			'config thinking: expected one of off, minimal, low, medium, high, xhigh, got "loud". Fix the value in roundtable.config.ts.',
-		);
-		expect(
-			refused({ ...minimal, http: { publicUrl: "https://x", port: 70000 } }),
-		).toContain(
-			"config http.port: expected an integer from 1 to 65535, got 70000.",
-		);
-		expect(refused({ ...minimal, model: "sonnet" })).toBe(
-			'config model: expected <provider>/<id>, got "sonnet". Write it like anthropic/claude-sonnet-5-5.',
-		);
-		expect(refused({ ...minimal, locale: "fr" })).toContain(
-			"config locale: expected a locale, en or zh-TW",
-		);
-		expect(refused({ ...minimal, toolTiers: { shell: "root" } })).toContain(
-			"config toolTiers.shell: expected one of owner, admin, member",
-		);
-		expect(refused({ ...minimal, plugins: [{ name: "x" }] })).toContain(
-			"config plugins[0]: expected a plugin, an object with a name and a setup function",
-		);
-		expect(refused("nope")).toContain("expected an object");
-	});
-
-	test("agents are seeds with their four texts", () => {
-		const seed = {
-			name: "coordinator",
-			displayName: "Coordinator",
-			prompt: "You coordinate.",
-			avatarPrompt: "A calm coordinator.",
-			channelId: "900000000000000002",
-		};
-		expect(resolveConfig({ ...minimal, agents: [seed] }).agents).toEqual([
-			seed,
-		]);
-		expect(refused({ ...minimal, agents: [{ name: "x" }] })).toContain(
-			"config agents[0].displayName: required",
-		);
-	});
-});