pi-roundtable 0.4.0 → 0.5.1

package/src/core/discord/owner-discord-threads.ts

@@ -64,18 +64,22 @@ export class OwnerThreads {
 					permissions.has(PermissionFlagsBits.ManageThreads))
 			);
 		};
-		return threads
-			.filter((t) => sees(owner, t) && sees(bot, t))
-			.map((t) => ({
-				id: t.id,
-				name: t.name,
-				parentId: t.parentId,
-				private: t.type === ChannelType.PrivateThread,
-				archived: t.archived,
-				locked: t.locked,
-				messageCount: t.messageCount,
-				createdAt: t.createdAt?.toISOString() ?? null,
-			}));
+		return threads.flatMap((t) =>
+			sees(owner, t) && sees(bot, t)
+				? [
+						{
+							id: t.id,
+							name: t.name,
+							parentId: t.parentId,
+							private: t.type === ChannelType.PrivateThread,
+							archived: t.archived,
+							locked: t.locked,
+							messageCount: t.messageCount,
+							createdAt: t.createdAt?.toISOString() ?? null,
+						},
+					]
+				: [],
+		);
 	}
 
 	async create(args: Record<string, unknown>) {

package/src/core/discord/owner-discord.ts

@@ -153,9 +153,9 @@ export class DiscordOwnerOps implements OwnerOperations {
 					displayName: m.displayName,
 					nickname: m.nickname,
 					bot: m.user.bot,
-					roles: m.roles.cache
-						.filter((r) => r.id !== guild.id)
-						.map((r) => r.name),
+					roles: [...m.roles.cache.values()].flatMap((r) =>
+						r.id === guild.id ? [] : [r.name],
+					),
 				}));
 			}
 			case "discord_create_role": {
@@ -233,8 +233,9 @@ export class DiscordOwnerOps implements OwnerOperations {
 				await guild.members.unban(userId, reason);
 				return { userId, banned: false };
 			}
+			default:
+				throw refuse("INVALID_TOOL", tool);
 		}
-		throw refuse("INVALID_TOOL", tool);
 	}
 
 	/** Servers the owner and the assistant share, with what each of them may do there. */

package/src/core/host.ts

@@ -109,6 +109,7 @@ async function startInBackground(
 ): Promise<void> {
 	const { services, servicePlugins, handlers } = registry;
 	await Promise.all(
+		// pi-lens-ignore: array-callback-return — an async callback returns its promise on every path; map only starts the tasks for Promise.all, and the early return skips a service with no background start
 		services.map(async (service) => {
 			if (!service.startInBackground) return;
 			const plugin = servicePlugins.get(service) ?? "unknown";

package/src/core/log.ts

@@ -2,6 +2,7 @@ import pino from "pino";
 
 /** One log method: fields and a message, or a message alone. */
 export interface LogFn {
+	// pi-lens-ignore: no-bare-object-param — LogFn is public API and pino's own call signature takes any object; a narrower type would refuse loggers that pass an interface-typed value
 	(fields: object, message?: string): void;
 	(message: string): void;
 }

package/src/core/modules/schedules/scheduler.ts

@@ -31,6 +31,8 @@ function statusText(outcome: ScheduledOutcome): string {
 			return `failed: ${outcome.error}`.slice(0, 300);
 		case "skipped":
 			return `skipped: ${outcome.reason}`;
+		default:
+			return outcome satisfies never;
 	}
 }
 
@@ -99,6 +101,7 @@ export class Scheduler {
 
 	/** Resolves once every started run has finished. */
 	async idle(): Promise<void> {
+		// pi-lens-ignore: no-single-promise-in-promise-methods — the spread holds every run in flight, none to many; it is not one promise
 		await Promise.all([...this.#running]);
 	}
 

package/src/core/modules/skills/skill-link.ts

@@ -4,6 +4,18 @@ import { AgentError } from "../../domain/errors.ts";
 import { checkRepoName } from "./repo-name.ts";
 import { checkSkillName, readSkillFile } from "./skill-rules.ts";
 
+/** The child folders of `dir` that hold a SKILL.md, as paths from the repository root. */
+function skillFoldersUnder(dir: string, relative: string): string[] {
+	const prefix = relative ? `${relative}/` : "";
+	const folders = readdirSync(dir, { withFileTypes: true }).flatMap((entry) =>
+		entry.isDirectory() && existsSync(join(dir, entry.name, "SKILL.md"))
+			? [`${prefix}${entry.name}`]
+			: [],
+	);
+	// pi-lens-ignore: no-sort-without-comparator — folder paths sort by code unit, the same order on every machine
+	return folders.sort();
+}
+
 /**
  * The skills a link would register: the one at a repository path, or every child folder with a
  * SKILL.md (behavior 15). Throws one error listing every problem, so nothing is half linked.
@@ -28,14 +40,7 @@ export function planLinkedSkills(
 		throw new AgentError(`${repo} has no folder ${relative || "."}.`);
 	const folders = existsSync(join(dir, "SKILL.md"))
 		? [relative]
-		: readdirSync(dir, { withFileTypes: true })
-				.filter(
-					(entry) =>
-						entry.isDirectory() &&
-						existsSync(join(dir, entry.name, "SKILL.md")),
-				)
-				.map((entry) => (relative ? `${relative}/${entry.name}` : entry.name))
-				.sort();
+		: skillFoldersUnder(dir, relative);
 	if (folders.length === 0)
 		throw new AgentError(
 			`${repo}:${relative || "."} has no SKILL.md, nor any folder with one.`,

package/src/core/modules/skills/skill-listing.ts

@@ -42,8 +42,7 @@ export function skillCatalog(
 				: { description: one.description, file: one.file }),
 			groups: store
 				.groups()
-				.filter((g) => g.skills.includes(name))
-				.map((g) => g.name),
+				.flatMap((g) => (g.skills.includes(name) ? [g.name] : [])),
 			carriers: store.carriers(name),
 		};
 	});
@@ -93,8 +92,7 @@ export function skillListText(
 			continue;
 		const groups = store
 			.groups()
-			.filter((g) => g.skills.includes(name))
-			.map((g) => g.name);
+			.flatMap((g) => (g.skills.includes(name) ? [g.name] : []));
 		const carriers = store.carriers(name);
 		const missing = "reason" in one ? ` — missing: ${one.reason}` : "";
 		rows.push(

package/src/core/modules/skills/skill-registry.ts

@@ -80,8 +80,9 @@ export class StoredSkillRegistry implements SkillRegistry {
 	linkedFrom(repo: string): string[] {
 		return this.#options.store
 			.skills()
-			.filter((entry) => entry.kind === "linked" && entry.repo === repo)
-			.map((entry) => entry.name);
+			.flatMap((entry) =>
+				entry.kind === "linked" && entry.repo === repo ? [entry.name] : [],
+			);
 	}
 
 	/** The registered skills an agent carries, as the dashboard lists them. */

package/src/core/modules/skills/skill-store.ts

@@ -177,9 +177,9 @@ export class SkillStore {
 
 	/** The agents carrying a skill. */
 	carriers(skill: string): string[] {
+		// pi-lens-ignore: no-sort-without-comparator — agent names sort by code unit, the same order on every machine
 		return [...this.#carried]
-			.filter(([, skills]) => skills.includes(skill))
-			.map(([agent]) => agent)
+			.flatMap(([agent, skills]) => (skills.includes(skill) ? [agent] : []))
 			.sort();
 	}
 
@@ -260,6 +260,7 @@ export class SkillStore {
 
 	/** Replaces the registered skills an agent carries. */
 	async setCarried(agent: string, skills: readonly string[]): Promise<void> {
+		// pi-lens-ignore: no-sort-without-comparator — skill names sort by code unit, the same order on every machine
 		const sorted = [...new Set(skills)].sort();
 		await this.#sql.begin(async (tx) => {
 			await tx`DELETE FROM agent_skills WHERE guild_id = ${this.#guild} AND agent = ${agent}`;

package/src/core/registry/contributions.ts

@@ -403,7 +403,7 @@ export function linkSessions(registry: Registry): LinkedSessions {
 		prompt: registry.prompt,
 		persona: (kind) => personas.get(kind)?.prompt(),
 		requiredTools: [...new Set(registry.requiredTools)],
-		agentTools: registry.tools.filter((t) => t.agent).map((t) => t.name),
+		agentTools: registry.tools.flatMap((t) => (t.agent ? [t.name] : [])),
 		agentSelection: () => mergeSelections(registry.agentSelections),
 	};
 }

package/src/core/routing/conversation-turns.ts

@@ -9,7 +9,7 @@ import { splitReply } from "../presentation/reply-splitter.ts";
 import { thinkingLine } from "../presentation/thinking-line.ts";
 import type { ChannelKey, ToolSelection, TurnSelection } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
-import { settleTurn } from "./settle-turn.ts";
+import { endOf, settleTurn } from "./settle-turn.ts";
 
 /** One turn of a conversation, as a claim asks for it. */
 export interface ConversationTurnInput {
@@ -106,7 +106,7 @@ export function conversationTurns(
 			}
 			events.turnEnded({
 				...turn,
-				result: result.ok ? "ok" : result.stopped ? "stopped" : "failed",
+				result: endOf(result),
 			});
 			try {
 				if (!result.ok && !result.stopped)

package/src/core/routing/settle-turn.ts

@@ -1,5 +1,7 @@
 import type { ScheduledOutcome } from "../contract/channels.ts";
+import type { TurnResult } from "../domain/conversation.ts";
 import { AgentRunError } from "../domain/errors.ts";
+import type { TurnEndEvent } from "../plugin.ts";
 
 /** Runs a turn; a thrown error becomes its failed result, labelled `<what> crashed`. */
 export async function settleTurn<R>(
@@ -16,6 +18,12 @@ export async function settleTurn<R>(
 	}
 }
 
+/** How a turn ended, as the `turnEnded` event reports it. */
+export function endOf(result: TurnResult): TurnEndEvent["result"] {
+	if (result.ok) return "ok";
+	return result.stopped ? "stopped" : "failed";
+}
+
 /** The result of a turn nobody wrote, as the scheduler and reports see it. */
 export function outcome(
 	result: { ok: true } | { ok: false; error: { message: string } },

package/src/core/runtime/compaction-tiers.ts

@@ -182,19 +182,18 @@ export class CompactionTiers {
 				event: string,
 				handler: Handler,
 			) => () => void;
-			const on = ((event: string, handler: Handler) =>
-				register(
-					event,
-					event === "session_before_compact"
-						? (compaction, ctx) =>
-								gate(compaction as SessionBeforeCompactEvent)
-									? handler(compaction, ctx)
-									: undefined
-						: handler,
-				)) as ExtensionAPI["on"];
+			const on = ((event: string, handler: Handler) => {
+				if (event !== "session_before_compact") return register(event, handler);
+				return register(event, (compaction, ctx) =>
+					gate(compaction as SessionBeforeCompactEvent)
+						? handler(compaction, ctx)
+						: undefined,
+				);
+			}) as ExtensionAPI["on"];
 			return compactor(
 				new Proxy(pi, {
 					get: (target, prop, receiver) =>
+						// pi-lens-ignore: no-reflect-get — a Proxy get trap: the receiver keeps a getter's `this` on the proxy, which target[prop] would not
 						prop === "on" ? on : Reflect.get(target, prop, receiver),
 				}),
 			);

package/src/core/runtime/turn-answer.ts

@@ -34,15 +34,13 @@ export function thinkingOf(messages: readonly Message[]): string {
 				? (message.content as (MessagePart | undefined)[])
 				: [],
 		)
-		.filter(
-			(
-				part,
-			): part is { type: "thinking"; thinking: string; redacted?: boolean } =>
-				part?.type === "thinking" &&
-				typeof part.thinking === "string" &&
-				part.redacted !== true,
+		.flatMap((part) =>
+			part?.type === "thinking" &&
+			typeof part.thinking === "string" &&
+			part.redacted !== true
+				? [part.thinking.trim()]
+				: [],
 		)
-		.map((part) => part.thinking.trim())
 		.filter(Boolean)
 		.join("\n\n");
 }
@@ -60,11 +58,11 @@ export function turnAnswer(
 	const text = (
 		steered
 			? messages
-					.filter(
-						(message): message is Assistant =>
-							isAssistant(message) && message.stopReason === "stop",
+					.flatMap((message) =>
+						isAssistant(message) && message.stopReason === "stop"
+							? [textOf(message.content).trim()]
+							: [],
 					)
-					.map((message) => textOf(message.content).trim())
 					.filter(Boolean)
 					.join("\n\n")
 			: textOf(last.message.content)

package/src/core/shared/session-messages.ts

@@ -11,11 +11,11 @@ export function textOf(content: unknown): string {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
 	return content
-		.filter(
-			(part): part is { type: "text"; text: string } =>
-				part?.type === "text" && typeof part.text === "string",
+		.flatMap((part) =>
+			part?.type === "text" && typeof part.text === "string"
+				? [part.text as string]
+				: [],
 		)
-		.map((part) => part.text)
 		.join("\n");
 }
 

package/src/core/speakers.ts

@@ -75,7 +75,10 @@ export interface SpeakerPolicy {
 	resolve(author: SpeakerFacts): Speaker | undefined;
 }
 
-/** Who holds one tier: user ids, role ids, and (for members) everyone. */
+/**
+ * Who holds one tier: user ids, role ids, or everyone. `everyone` works under any tier it is
+ * written in, so under `admins` it makes every author an admin.
+ */
 export interface TierMembers {
 	users?: readonly string[];
 	roles?: readonly string[];

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

@@ -102,6 +102,7 @@
 				"skill_group_delete",
 				"skill_group_set",
 				"skill_link",
+				"skill_list",
 				"skill_unlink",
 				"skill_update"
 			],
@@ -125,6 +126,7 @@
 				"skill_group_delete",
 				"skill_group_set",
 				"skill_link",
+				"skill_list",
 				"skill_unlink",
 				"skill_update",
 				"write"
@@ -187,6 +189,7 @@
 				"skill_group_delete",
 				"skill_group_set",
 				"skill_link",
+				"skill_list",
 				"skill_unlink",
 				"skill_update"
 			],
@@ -209,6 +212,7 @@
 				"skill_group_delete",
 				"skill_group_set",
 				"skill_link",
+				"skill_list",
 				"skill_unlink",
 				"skill_update",
 				"write"
@@ -280,6 +284,7 @@
 		"skill_group_delete": "admin",
 		"skill_group_set": "admin",
 		"skill_link": "admin",
+		"skill_list": "member",
 		"skill_unlink": "admin",
 		"skill_update": "admin",
 		"web_search": "member",

package/templates/official/codex-images/plugin.ts

@@ -35,7 +35,7 @@ export interface CodexImagesOptions {
 
 /** The ChatGPT account the login token belongs to, from the token's claims. */
 function chatGptAccountId(token: string): string {
-	const payload = token.split(".")[1];
+	const [, payload] = token.split(".");
 	if (!payload) throw new Error("the Codex token is not a JWT");
 	let claims: Record<string, unknown>;
 	try {
@@ -58,43 +58,64 @@ function object(value: unknown): Record<string, unknown> {
 		: {};
 }
 
-/** Reads the server-sent events until the response completes, and returns its one image. */
+/** The one image an `image_generation_call` item carries; anything else is not an image. */
+function imageOf(value: unknown): Uint8Array | undefined {
+	const item = object(value);
+	if (item.type !== "image_generation_call") return undefined;
+	if (
+		item.status !== "completed" ||
+		typeof item.result !== "string" ||
+		!item.result
+	) {
+		const { result: _result, ...detail } = item;
+		throw new ImageNotGeneratedError(
+			`Codex image generation did not complete (status ${String(item.status)}): ${JSON.stringify(detail).slice(0, 300)}`,
+		);
+	}
+	if (item.result.length > MAX_IMAGE_BASE64)
+		throw new Error("the image exceeds 32 MiB");
+	return new Uint8Array(Buffer.from(item.result, "base64"));
+}
+
+/** The frames of a server-sent event stream: the text between blank lines. */
+async function* frames(
+	body: ReadableStream<Uint8Array>,
+): AsyncGenerator<string> {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for await (const chunk of body) {
+		buffer += decoder.decode(chunk, { stream: true });
+		let match = /\r?\n\r?\n/.exec(buffer);
+		while (match) {
+			yield buffer.slice(0, match.index);
+			buffer = buffer.slice(match.index + match[0].length);
+			match = /\r?\n\r?\n/.exec(buffer);
+		}
+	}
+	if (buffer.trim()) yield buffer;
+}
+
+/** The event a frame carries, or undefined for a frame without data. */
+function eventOf(frame: string): Record<string, unknown> | undefined {
+	const data = frame
+		.split(/\r?\n/)
+		.flatMap((line) => (line.startsWith("data:") ? [line.slice(5).trim()] : []))
+		.join("\n");
+	if (!data || data === "[DONE]") return undefined;
+	try {
+		return object(JSON.parse(data));
+	} catch {
+		throw new Error(`Codex sent a malformed event: ${data.slice(0, 200)}`);
+	}
+}
+
+/** Reads the events until the response completes, and returns its one image. */
 async function parseImageStream(response: Response): Promise<Uint8Array> {
 	if (!response.body) throw new Error("Codex returned no body");
 	let image: Uint8Array | undefined;
-	let completed = false;
-	const take = (value: unknown) => {
-		const item = object(value);
-		if (item.type !== "image_generation_call" || image) return;
-		if (
-			item.status !== "completed" ||
-			typeof item.result !== "string" ||
-			!item.result
-		) {
-			const { result: _result, ...detail } = item;
-			throw new ImageNotGeneratedError(
-				`Codex image generation did not complete (status ${String(item.status)}): ${JSON.stringify(detail).slice(0, 300)}`,
-			);
-		}
-		if (item.result.length > MAX_IMAGE_BASE64)
-			throw new Error("the image exceeds 32 MiB");
-		image = new Uint8Array(Buffer.from(item.result, "base64"));
-	};
-	const handle = (frame: string) => {
-		const data = frame
-			.split(/\r?\n/)
-			.filter((line) => line.startsWith("data:"))
-			.map((line) => line.slice(5).trim())
-			.join("\n");
-		if (!data || data === "[DONE]") return;
-		let parsed: unknown;
-		try {
-			parsed = JSON.parse(data);
-		} catch {
-			throw new Error(`Codex sent a malformed event: ${data.slice(0, 200)}`);
-		}
-		const event = object(parsed);
-		switch (event.type) {
+	for await (const frame of frames(response.body)) {
+		const event = eventOf(frame);
+		switch (event?.type) {
 			case "error":
 			case "response.failed": {
 				const error = object(object(event.response).error ?? event.error);
@@ -105,34 +126,21 @@ async function parseImageStream(response: Response): Promise<Uint8Array> {
 			case "response.incomplete":
 				throw new Error("the Codex response was incomplete");
 			case "response.output_item.done":
-				take(event.item);
+				image ??= imageOf(event.item);
 				break;
 			case "response.completed": {
 				const output = object(event.response).output;
-				if (!image && Array.isArray(output))
-					for (const item of output) take(item);
-				completed = true;
-				break;
+				if (Array.isArray(output))
+					for (const item of output) image ??= imageOf(item);
+				if (!image)
+					throw new ImageNotGeneratedError("Codex answered without an image");
+				return image;
 			}
+			default:
+				break;
 		}
-	};
-	const decoder = new TextDecoder();
-	let buffer = "";
-	for await (const chunk of response.body) {
-		buffer += decoder.decode(chunk, { stream: true });
-		let match = /\r?\n\r?\n/.exec(buffer);
-		while (match && !completed) {
-			handle(buffer.slice(0, match.index));
-			buffer = buffer.slice(match.index + match[0].length);
-			match = /\r?\n\r?\n/.exec(buffer);
-		}
-		if (completed) break;
 	}
-	if (!completed && buffer.trim()) handle(buffer);
-	if (!completed) throw new Error("the Codex stream ended before completion");
-	if (!image)
-		throw new ImageNotGeneratedError("Codex answered without an image");
-	return image;
+	throw new Error("the Codex stream ended before completion");
 }
 
 async function generateImage(