pi-roundtable 0.5.0 → 0.5.2

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");
 }